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

#	count	content
1	n/a	/* -----------------------------------------------------------------------
2	n/a	ffi.c - Copyright (c) 2011 Anthony Green
3	n/a	Copyright (c) 2008 David Daney
4	n/a	Copyright (c) 1996, 2007, 2008, 2011 Red Hat, Inc.
5	n/a
6	n/a	MIPS Foreign Function Interface
7	n/a
8	n/a	Permission is hereby granted, free of charge, to any person obtaining
9	n/a	a copy of this software and associated documentation files (the
10	n/a	``Software''), to deal in the Software without restriction, including
11	n/a	without limitation the rights to use, copy, modify, merge, publish,
12	n/a	distribute, sublicense, and/or sell copies of the Software, and to
13	n/a	permit persons to whom the Software is furnished to do so, subject to
14	n/a	the following conditions:
15	n/a
16	n/a	The above copyright notice and this permission notice shall be included
17	n/a	in all copies or substantial portions of the Software.
18	n/a
19	n/a	THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
20	n/a	EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
21	n/a	MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
22	n/a	NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
23	n/a	HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
24	n/a	WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
25	n/a	OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
26	n/a	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	#include <stdlib.h>
33	n/a
34	n/a	#ifdef __GNUC__
35	n/a	# if (__GNUC__ > 4) \|\| ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3))
36	n/a	# define USE__BUILTIN___CLEAR_CACHE 1
37	n/a	# endif
38	n/a	#endif
39	n/a
40	n/a	#ifndef USE__BUILTIN___CLEAR_CACHE
41	n/a	# if defined(__OpenBSD__)
42	n/a	# include <mips64/sysarch.h>
43	n/a	# else
44	n/a	# include <sys/cachectl.h>
45	n/a	# endif
46	n/a	#endif
47	n/a
48	n/a	#ifdef FFI_DEBUG
49	n/a	# define FFI_MIPS_STOP_HERE() ffi_stop_here()
50	n/a	#else
51	n/a	# define FFI_MIPS_STOP_HERE() do {} while(0)
52	n/a	#endif
53	n/a
54	n/a	#ifdef FFI_MIPS_N32
55	n/a	#define FIX_ARGP \
56	n/a	FFI_ASSERT(argp <= &stack[bytes]); \
57	n/a	if (argp == &stack[bytes]) \
58	n/a	{ \
59	n/a	argp = stack; \
60	n/a	FFI_MIPS_STOP_HERE(); \
61	n/a	}
62	n/a	#else
63	n/a	#define FIX_ARGP
64	n/a	#endif
65	n/a
66	n/a
67	n/a	/* ffi_prep_args is called by the assembly routine once stack space
68	n/a	has been allocated for the function's arguments */
69	n/a
70	n/a	static void ffi_prep_args(char *stack,
71	n/a	extended_cif *ecif,
72	n/a	int bytes,
73	n/a	int flags)
74	n/a	{
75	n/a	int i;
76	n/a	void **p_argv;
77	n/a	char *argp;
78	n/a	ffi_type **p_arg;
79	n/a
80	n/a	#ifdef FFI_MIPS_N32
81	n/a	/* If more than 8 double words are used, the remainder go
82	n/a	on the stack. We reorder stuff on the stack here to
83	n/a	support this easily. */
84	n/a	if (bytes > 8 * sizeof(ffi_arg))
85	n/a	argp = &stack[bytes - (8 * sizeof(ffi_arg))];
86	n/a	else
87	n/a	argp = stack;
88	n/a	#else
89	n/a	argp = stack;
90	n/a	#endif
91	n/a
92	n/a	memset(stack, 0, bytes);
93	n/a
94	n/a	#ifdef FFI_MIPS_N32
95	n/a	if ( ecif->cif->rstruct_flag != 0 )
96	n/a	#else
97	n/a	if ( ecif->cif->rtype->type == FFI_TYPE_STRUCT )
98	n/a	#endif
99	n/a	{
100	n/a	(ffi_arg ) argp = (ffi_arg) ecif->rvalue;
101	n/a	argp += sizeof(ffi_arg);
102	n/a	FIX_ARGP;
103	n/a	}
104	n/a
105	n/a	p_argv = ecif->avalue;
106	n/a
107	n/a	for (i = 0, p_arg = ecif->cif->arg_types; i < ecif->cif->nargs; i++, p_arg++)
108	n/a	{
109	n/a	size_t z;
110	n/a	unsigned int a;
111	n/a
112	n/a	/* Align if necessary. */
113	n/a	a = (*p_arg)->alignment;
114	n/a	if (a < sizeof(ffi_arg))
115	n/a	a = sizeof(ffi_arg);
116	n/a
117	n/a	if ((a - 1) & (unsigned long) argp)
118	n/a	{
119	n/a	argp = (char *) ALIGN(argp, a);
120	n/a	FIX_ARGP;
121	n/a	}
122	n/a
123	n/a	z = (*p_arg)->size;
124	n/a	if (z <= sizeof(ffi_arg))
125	n/a	{
126	n/a	int type = (*p_arg)->type;
127	n/a	z = sizeof(ffi_arg);
128	n/a
129	n/a	/* The size of a pointer depends on the ABI */
130	n/a	if (type == FFI_TYPE_POINTER)
131	n/a	type = (ecif->cif->abi == FFI_N64
132	n/a	\|\| ecif->cif->abi == FFI_N64_SOFT_FLOAT)
133	n/a	? FFI_TYPE_SINT64 : FFI_TYPE_SINT32;
134	n/a
135	n/a	if (i < 8 && (ecif->cif->abi == FFI_N32_SOFT_FLOAT
136	n/a	\|\| ecif->cif->abi == FFI_N64_SOFT_FLOAT))
137	n/a	{
138	n/a	switch (type)
139	n/a	{
140	n/a	case FFI_TYPE_FLOAT:
141	n/a	type = FFI_TYPE_UINT32;
142	n/a	break;
143	n/a	case FFI_TYPE_DOUBLE:
144	n/a	type = FFI_TYPE_UINT64;
145	n/a	break;
146	n/a	default:
147	n/a	break;
148	n/a	}
149	n/a	}
150	n/a	switch (type)
151	n/a	{
152	n/a	case FFI_TYPE_SINT8:
153	n/a	(ffi_arg )argp = (SINT8 )(* p_argv);
154	n/a	break;
155	n/a
156	n/a	case FFI_TYPE_UINT8:
157	n/a	(ffi_arg )argp = (UINT8 )(* p_argv);
158	n/a	break;
159	n/a
160	n/a	case FFI_TYPE_SINT16:
161	n/a	(ffi_arg )argp = (SINT16 )(* p_argv);
162	n/a	break;
163	n/a
164	n/a	case FFI_TYPE_UINT16:
165	n/a	(ffi_arg )argp = (UINT16 )(* p_argv);
166	n/a	break;
167	n/a
168	n/a	case FFI_TYPE_SINT32:
169	n/a	(ffi_arg )argp = (SINT32 )(* p_argv);
170	n/a	break;
171	n/a
172	n/a	case FFI_TYPE_UINT32:
173	n/a	#ifdef FFI_MIPS_N32
174	n/a	/* The N32 ABI requires that 32-bit integers
175	n/a	be sign-extended to 64-bits, regardless of
176	n/a	whether they are signed or unsigned. */
177	n/a	(ffi_arg )argp = (SINT32 )(* p_argv);
178	n/a	#else
179	n/a	(ffi_arg )argp = (UINT32 )(* p_argv);
180	n/a	#endif
181	n/a	break;
182	n/a
183	n/a	/* This can only happen with 64bit slots. */
184	n/a	case FFI_TYPE_FLOAT:
185	n/a	(float ) argp = (float )(* p_argv);
186	n/a	break;
187	n/a
188	n/a	/* Handle structures. */
189	n/a	default:
190	n/a	memcpy(argp, p_argv, (p_arg)->size);
191	n/a	break;
192	n/a	}
193	n/a	}
194	n/a	else
195	n/a	{
196	n/a	#ifdef FFI_MIPS_O32
197	n/a	memcpy(argp, *p_argv, z);
198	n/a	#else
199	n/a	{
200	n/a	unsigned long end = (unsigned long) argp + z;
201	n/a	unsigned long cap = (unsigned long) stack + bytes;
202	n/a
203	n/a	/* Check if the data will fit within the register space.
204	n/a	Handle it if it doesn't. */
205	n/a
206	n/a	if (end <= cap)
207	n/a	memcpy(argp, *p_argv, z);
208	n/a	else
209	n/a	{
210	n/a	unsigned long portion = cap - (unsigned long)argp;
211	n/a
212	n/a	memcpy(argp, *p_argv, portion);
213	n/a	argp = stack;
214	n/a	z -= portion;
215	n/a	memcpy(argp, (void)((unsigned long)(p_argv) + portion),
216	n/a	z);
217	n/a	}
218	n/a	}
219	n/a	#endif
220	n/a	}
221	n/a	p_argv++;
222	n/a	argp += z;
223	n/a	FIX_ARGP;
224	n/a	}
225	n/a	}
226	n/a
227	n/a	#ifdef FFI_MIPS_N32
228	n/a
229	n/a	/* The n32 spec says that if "a chunk consists solely of a double
230	n/a	float field (but not a double, which is part of a union), it
231	n/a	is passed in a floating point register. Any other chunk is
232	n/a	passed in an integer register". This code traverses structure
233	n/a	definitions and generates the appropriate flags. */
234	n/a
235	n/a	static unsigned
236	n/a	calc_n32_struct_flags(int soft_float, ffi_type *arg,
237	n/a	unsigned loc, unsigned arg_reg)
238	n/a	{
239	n/a	unsigned flags = 0;
240	n/a	unsigned index = 0;
241	n/a
242	n/a	ffi_type *e;
243	n/a
244	n/a	if (soft_float)
245	n/a	return 0;
246	n/a
247	n/a	while ((e = arg->elements[index]))
248	n/a	{
249	n/a	/* Align this object. */
250	n/a	loc = ALIGN(loc, e->alignment);
251	n/a	if (e->type == FFI_TYPE_DOUBLE)
252	n/a	{
253	n/a	/* Already aligned to FFI_SIZEOF_ARG. */
254	n/a	arg_reg = loc / FFI_SIZEOF_ARG;
255	n/a	if (*arg_reg > 7)
256	n/a	break;
257	n/a	flags += (FFI_TYPE_DOUBLE << (arg_reg FFI_FLAG_BITS));
258	n/a	*loc += e->size;
259	n/a	}
260	n/a	else
261	n/a	*loc += e->size;
262	n/a	index++;
263	n/a	}
264	n/a	/* Next Argument register at alignment of FFI_SIZEOF_ARG. */
265	n/a	arg_reg = ALIGN(loc, FFI_SIZEOF_ARG) / FFI_SIZEOF_ARG;
266	n/a
267	n/a	return flags;
268	n/a	}
269	n/a
270	n/a	static unsigned
271	n/a	calc_n32_return_struct_flags(int soft_float, ffi_type *arg)
272	n/a	{
273	n/a	unsigned flags = 0;
274	n/a	unsigned small = FFI_TYPE_SMALLSTRUCT;
275	n/a	ffi_type *e;
276	n/a
277	n/a	/* Returning structures under n32 is a tricky thing.
278	n/a	A struct with only one or two floating point fields
279	n/a	is returned in $f0 (and $f2 if necessary). Any other
280	n/a	struct results at most 128 bits are returned in $2
281	n/a	(the first 64 bits) and $3 (remainder, if necessary).
282	n/a	Larger structs are handled normally. */
283	n/a
284	n/a	if (arg->size > 16)
285	n/a	return 0;
286	n/a
287	n/a	if (arg->size > 8)
288	n/a	small = FFI_TYPE_SMALLSTRUCT2;
289	n/a
290	n/a	e = arg->elements[0];
291	n/a
292	n/a	if (e->type == FFI_TYPE_DOUBLE)
293	n/a	flags = FFI_TYPE_DOUBLE;
294	n/a	else if (e->type == FFI_TYPE_FLOAT)
295	n/a	flags = FFI_TYPE_FLOAT;
296	n/a
297	n/a	if (flags && (e = arg->elements[1]))
298	n/a	{
299	n/a	if (e->type == FFI_TYPE_DOUBLE)
300	n/a	flags += FFI_TYPE_DOUBLE << FFI_FLAG_BITS;
301	n/a	else if (e->type == FFI_TYPE_FLOAT)
302	n/a	flags += FFI_TYPE_FLOAT << FFI_FLAG_BITS;
303	n/a	else
304	n/a	return small;
305	n/a
306	n/a	if (flags && (arg->elements[2]))
307	n/a	{
308	n/a	/* There are three arguments and the first two are
309	n/a	floats! This must be passed the old way. */
310	n/a	return small;
311	n/a	}
312	n/a	if (soft_float)
313	n/a	flags += FFI_TYPE_STRUCT_SOFT;
314	n/a	}
315	n/a	else
316	n/a	if (!flags)
317	n/a	return small;
318	n/a
319	n/a	return flags;
320	n/a	}
321	n/a
322	n/a	#endif
323	n/a
324	n/a	/* Perform machine dependent cif processing */
325	n/a	ffi_status ffi_prep_cif_machdep(ffi_cif *cif)
326	n/a	{
327	n/a	cif->flags = 0;
328	n/a
329	n/a	#ifdef FFI_MIPS_O32
330	n/a	/* Set the flags necessary for O32 processing. FFI_O32_SOFT_FLOAT
331	n/a	* does not have special handling for floating point args.
332	n/a	*/
333	n/a
334	n/a	if (cif->rtype->type != FFI_TYPE_STRUCT && cif->abi == FFI_O32)
335	n/a	{
336	n/a	if (cif->nargs > 0)
337	n/a	{
338	n/a	switch ((cif->arg_types)[0]->type)
339	n/a	{
340	n/a	case FFI_TYPE_FLOAT:
341	n/a	case FFI_TYPE_DOUBLE:
342	n/a	cif->flags += (cif->arg_types)[0]->type;
343	n/a	break;
344	n/a
345	n/a	default:
346	n/a	break;
347	n/a	}
348	n/a
349	n/a	if (cif->nargs > 1)
350	n/a	{
351	n/a	/* Only handle the second argument if the first
352	n/a	is a float or double. */
353	n/a	if (cif->flags)
354	n/a	{
355	n/a	switch ((cif->arg_types)[1]->type)
356	n/a	{
357	n/a	case FFI_TYPE_FLOAT:
358	n/a	case FFI_TYPE_DOUBLE:
359	n/a	cif->flags += (cif->arg_types)[1]->type << FFI_FLAG_BITS;
360	n/a	break;
361	n/a
362	n/a	default:
363	n/a	break;
364	n/a	}
365	n/a	}
366	n/a	}
367	n/a	}
368	n/a	}
369	n/a
370	n/a	/* Set the return type flag */
371	n/a
372	n/a	if (cif->abi == FFI_O32_SOFT_FLOAT)
373	n/a	{
374	n/a	switch (cif->rtype->type)
375	n/a	{
376	n/a	case FFI_TYPE_VOID:
377	n/a	case FFI_TYPE_STRUCT:
378	n/a	cif->flags += cif->rtype->type << (FFI_FLAG_BITS * 2);
379	n/a	break;
380	n/a
381	n/a	case FFI_TYPE_SINT64:
382	n/a	case FFI_TYPE_UINT64:
383	n/a	case FFI_TYPE_DOUBLE:
384	n/a	cif->flags += FFI_TYPE_UINT64 << (FFI_FLAG_BITS * 2);
385	n/a	break;
386	n/a
387	n/a	case FFI_TYPE_FLOAT:
388	n/a	default:
389	n/a	cif->flags += FFI_TYPE_INT << (FFI_FLAG_BITS * 2);
390	n/a	break;
391	n/a	}
392	n/a	}
393	n/a	else
394	n/a	{
395	n/a	/* FFI_O32 */
396	n/a	switch (cif->rtype->type)
397	n/a	{
398	n/a	case FFI_TYPE_VOID:
399	n/a	case FFI_TYPE_STRUCT:
400	n/a	case FFI_TYPE_FLOAT:
401	n/a	case FFI_TYPE_DOUBLE:
402	n/a	cif->flags += cif->rtype->type << (FFI_FLAG_BITS * 2);
403	n/a	break;
404	n/a
405	n/a	case FFI_TYPE_SINT64:
406	n/a	case FFI_TYPE_UINT64:
407	n/a	cif->flags += FFI_TYPE_UINT64 << (FFI_FLAG_BITS * 2);
408	n/a	break;
409	n/a
410	n/a	default:
411	n/a	cif->flags += FFI_TYPE_INT << (FFI_FLAG_BITS * 2);
412	n/a	break;
413	n/a	}
414	n/a	}
415	n/a	#endif
416	n/a
417	n/a	#ifdef FFI_MIPS_N32
418	n/a	/* Set the flags necessary for N32 processing */
419	n/a	{
420	n/a	int type;
421	n/a	unsigned arg_reg = 0;
422	n/a	unsigned loc = 0;
423	n/a	unsigned count = (cif->nargs < 8) ? cif->nargs : 8;
424	n/a	unsigned index = 0;
425	n/a
426	n/a	unsigned struct_flags = 0;
427	n/a	int soft_float = (cif->abi == FFI_N32_SOFT_FLOAT
428	n/a	\|\| cif->abi == FFI_N64_SOFT_FLOAT);
429	n/a
430	n/a	if (cif->rtype->type == FFI_TYPE_STRUCT)
431	n/a	{
432	n/a	struct_flags = calc_n32_return_struct_flags(soft_float, cif->rtype);
433	n/a
434	n/a	if (struct_flags == 0)
435	n/a	{
436	n/a	/* This means that the structure is being passed as
437	n/a	a hidden argument */
438	n/a
439	n/a	arg_reg = 1;
440	n/a	count = (cif->nargs < 7) ? cif->nargs : 7;
441	n/a
442	n/a	cif->rstruct_flag = !0;
443	n/a	}
444	n/a	else
445	n/a	cif->rstruct_flag = 0;
446	n/a	}
447	n/a	else
448	n/a	cif->rstruct_flag = 0;
449	n/a
450	n/a	while (count-- > 0 && arg_reg < 8)
451	n/a	{
452	n/a	type = (cif->arg_types)[index]->type;
453	n/a	if (soft_float)
454	n/a	{
455	n/a	switch (type)
456	n/a	{
457	n/a	case FFI_TYPE_FLOAT:
458	n/a	type = FFI_TYPE_UINT32;
459	n/a	break;
460	n/a	case FFI_TYPE_DOUBLE:
461	n/a	type = FFI_TYPE_UINT64;
462	n/a	break;
463	n/a	default:
464	n/a	break;
465	n/a	}
466	n/a	}
467	n/a	switch (type)
468	n/a	{
469	n/a	case FFI_TYPE_FLOAT:
470	n/a	case FFI_TYPE_DOUBLE:
471	n/a	cif->flags +=
472	n/a	((cif->arg_types)[index]->type << (arg_reg * FFI_FLAG_BITS));
473	n/a	arg_reg++;
474	n/a	break;
475	n/a	case FFI_TYPE_LONGDOUBLE:
476	n/a	/* Align it. */
477	n/a	arg_reg = ALIGN(arg_reg, 2);
478	n/a	/* Treat it as two adjacent doubles. */
479	n/a	if (soft_float)
480	n/a	{
481	n/a	arg_reg += 2;
482	n/a	}
483	n/a	else
484	n/a	{
485	n/a	cif->flags +=
486	n/a	(FFI_TYPE_DOUBLE << (arg_reg * FFI_FLAG_BITS));
487	n/a	arg_reg++;
488	n/a	cif->flags +=
489	n/a	(FFI_TYPE_DOUBLE << (arg_reg * FFI_FLAG_BITS));
490	n/a	arg_reg++;
491	n/a	}
492	n/a	break;
493	n/a
494	n/a	case FFI_TYPE_STRUCT:
495	n/a	loc = arg_reg * FFI_SIZEOF_ARG;
496	n/a	cif->flags += calc_n32_struct_flags(soft_float,
497	n/a	(cif->arg_types)[index],
498	n/a	&loc, &arg_reg);
499	n/a	break;
500	n/a
501	n/a	default:
502	n/a	arg_reg++;
503	n/a	break;
504	n/a	}
505	n/a
506	n/a	index++;
507	n/a	}
508	n/a
509	n/a	/* Set the return type flag */
510	n/a	switch (cif->rtype->type)
511	n/a	{
512	n/a	case FFI_TYPE_STRUCT:
513	n/a	{
514	n/a	if (struct_flags == 0)
515	n/a	{
516	n/a	/* The structure is returned through a hidden
517	n/a	first argument. Do nothing, 'cause FFI_TYPE_VOID
518	n/a	is 0 */
519	n/a	}
520	n/a	else
521	n/a	{
522	n/a	/* The structure is returned via some tricky
523	n/a	mechanism */
524	n/a	cif->flags += FFI_TYPE_STRUCT << (FFI_FLAG_BITS * 8);
525	n/a	cif->flags += struct_flags << (4 + (FFI_FLAG_BITS * 8));
526	n/a	}
527	n/a	break;
528	n/a	}
529	n/a
530	n/a	case FFI_TYPE_VOID:
531	n/a	/* Do nothing, 'cause FFI_TYPE_VOID is 0 */
532	n/a	break;
533	n/a
534	n/a	case FFI_TYPE_POINTER:
535	n/a	if (cif->abi == FFI_N32_SOFT_FLOAT \|\| cif->abi == FFI_N32)
536	n/a	cif->flags += FFI_TYPE_SINT32 << (FFI_FLAG_BITS * 8);
537	n/a	else
538	n/a	cif->flags += FFI_TYPE_INT << (FFI_FLAG_BITS * 8);
539	n/a	break;
540	n/a
541	n/a	case FFI_TYPE_FLOAT:
542	n/a	if (soft_float)
543	n/a	{
544	n/a	cif->flags += FFI_TYPE_SINT32 << (FFI_FLAG_BITS * 8);
545	n/a	break;
546	n/a	}
547	n/a	/* else fall through */
548	n/a	case FFI_TYPE_DOUBLE:
549	n/a	if (soft_float)
550	n/a	cif->flags += FFI_TYPE_INT << (FFI_FLAG_BITS * 8);
551	n/a	else
552	n/a	cif->flags += cif->rtype->type << (FFI_FLAG_BITS * 8);
553	n/a	break;
554	n/a
555	n/a	case FFI_TYPE_LONGDOUBLE:
556	n/a	/* Long double is returned as if it were a struct containing
557	n/a	two doubles. */
558	n/a	if (soft_float)
559	n/a	{
560	n/a	cif->flags += FFI_TYPE_STRUCT << (FFI_FLAG_BITS * 8);
561	n/a	cif->flags += FFI_TYPE_SMALLSTRUCT2 << (4 + (FFI_FLAG_BITS * 8));
562	n/a	}
563	n/a	else
564	n/a	{
565	n/a	cif->flags += FFI_TYPE_STRUCT << (FFI_FLAG_BITS * 8);
566	n/a	cif->flags += (FFI_TYPE_DOUBLE
567	n/a	+ (FFI_TYPE_DOUBLE << FFI_FLAG_BITS))
568	n/a	<< (4 + (FFI_FLAG_BITS * 8));
569	n/a	}
570	n/a	break;
571	n/a	default:
572	n/a	cif->flags += FFI_TYPE_INT << (FFI_FLAG_BITS * 8);
573	n/a	break;
574	n/a	}
575	n/a	}
576	n/a	#endif
577	n/a
578	n/a	return FFI_OK;
579	n/a	}
580	n/a
581	n/a	/* Low level routine for calling O32 functions */
582	n/a	extern int ffi_call_O32(void ()(char , extended_cif *, int, int),
583	n/a	extended_cif *, unsigned,
584	n/a	unsigned, unsigned , void ()(void));
585	n/a
586	n/a	/* Low level routine for calling N32 functions */
587	n/a	extern int ffi_call_N32(void ()(char , extended_cif *, int, int),
588	n/a	extended_cif *, unsigned,
589	n/a	unsigned, void , void ()(void));
590	n/a
591	n/a	void ffi_call(ffi_cif cif, void (fn)(void), void rvalue, void *avalue)
592	n/a	{
593	n/a	extended_cif ecif;
594	n/a
595	n/a	ecif.cif = cif;
596	n/a	ecif.avalue = avalue;
597	n/a
598	n/a	/* If the return value is a struct and we don't have a return */
599	n/a	/* value address then we need to make one */
600	n/a
601	n/a	if ((rvalue == NULL) &&
602	n/a	(cif->rtype->type == FFI_TYPE_STRUCT))
603	n/a	ecif.rvalue = alloca(cif->rtype->size);
604	n/a	else
605	n/a	ecif.rvalue = rvalue;
606	n/a
607	n/a	switch (cif->abi)
608	n/a	{
609	n/a	#ifdef FFI_MIPS_O32
610	n/a	case FFI_O32:
611	n/a	case FFI_O32_SOFT_FLOAT:
612	n/a	ffi_call_O32(ffi_prep_args, &ecif, cif->bytes,
613	n/a	cif->flags, ecif.rvalue, fn);
614	n/a	break;
615	n/a	#endif
616	n/a
617	n/a	#ifdef FFI_MIPS_N32
618	n/a	case FFI_N32:
619	n/a	case FFI_N32_SOFT_FLOAT:
620	n/a	case FFI_N64:
621	n/a	case FFI_N64_SOFT_FLOAT:
622	n/a	{
623	n/a	int copy_rvalue = 0;
624	n/a	int copy_offset = 0;
625	n/a	char *rvalue_copy = ecif.rvalue;
626	n/a	if (cif->rtype->type == FFI_TYPE_STRUCT && cif->rtype->size < 16)
627	n/a	{
628	n/a	/* For structures smaller than 16 bytes we clobber memory
629	n/a	in 8 byte increments. Make a copy so we don't clobber
630	n/a	the callers memory outside of the struct bounds. */
631	n/a	rvalue_copy = alloca(16);
632	n/a	copy_rvalue = 1;
633	n/a	}
634	n/a	else if (cif->rtype->type == FFI_TYPE_FLOAT
635	n/a	&& (cif->abi == FFI_N64_SOFT_FLOAT
636	n/a	\|\| cif->abi == FFI_N32_SOFT_FLOAT))
637	n/a	{
638	n/a	rvalue_copy = alloca (8);
639	n/a	copy_rvalue = 1;
640	n/a	#if defined(__MIPSEB__) \|\| defined(_MIPSEB)
641	n/a	copy_offset = 4;
642	n/a	#endif
643	n/a	}
644	n/a	ffi_call_N32(ffi_prep_args, &ecif, cif->bytes,
645	n/a	cif->flags, rvalue_copy, fn);
646	n/a	if (copy_rvalue)
647	n/a	memcpy(ecif.rvalue, rvalue_copy + copy_offset, cif->rtype->size);
648	n/a	}
649	n/a	break;
650	n/a	#endif
651	n/a
652	n/a	default:
653	n/a	FFI_ASSERT(0);
654	n/a	break;
655	n/a	}
656	n/a	}
657	n/a
658	n/a	#if FFI_CLOSURES
659	n/a	#if defined(FFI_MIPS_O32)
660	n/a	extern void ffi_closure_O32(void);
661	n/a	#else
662	n/a	extern void ffi_closure_N32(void);
663	n/a	#endif /* FFI_MIPS_O32 */
664	n/a
665	n/a	ffi_status
666	n/a	ffi_prep_closure_loc (ffi_closure *closure,
667	n/a	ffi_cif *cif,
668	n/a	void (fun)(ffi_cif,void,void,void),
669	n/a	void *user_data,
670	n/a	void *codeloc)
671	n/a	{
672	n/a	unsigned int tramp = (unsigned int ) &closure->tramp[0];
673	n/a	void * fn;
674	n/a	char clear_location = (char ) codeloc;
675	n/a
676	n/a	#if defined(FFI_MIPS_O32)
677	n/a	if (cif->abi != FFI_O32 && cif->abi != FFI_O32_SOFT_FLOAT)
678	n/a	return FFI_BAD_ABI;
679	n/a	fn = ffi_closure_O32;
680	n/a	#else
681	n/a	#if _MIPS_SIM ==_ABIN32
682	n/a	if (cif->abi != FFI_N32
683	n/a	&& cif->abi != FFI_N32_SOFT_FLOAT)
684	n/a	return FFI_BAD_ABI;
685	n/a	#else
686	n/a	if (cif->abi != FFI_N64
687	n/a	&& cif->abi != FFI_N64_SOFT_FLOAT)
688	n/a	return FFI_BAD_ABI;
689	n/a	#endif
690	n/a	fn = ffi_closure_N32;
691	n/a	#endif /* FFI_MIPS_O32 */
692	n/a
693	n/a	#if defined(FFI_MIPS_O32) \|\| (_MIPS_SIM ==_ABIN32)
694	n/a	/* lui $25,high(fn) */
695	n/a	tramp[0] = 0x3c190000 \| ((unsigned)fn >> 16);
696	n/a	/* ori $25,low(fn) */
697	n/a	tramp[1] = 0x37390000 \| ((unsigned)fn & 0xffff);
698	n/a	/* lui $12,high(codeloc) */
699	n/a	tramp[2] = 0x3c0c0000 \| ((unsigned)codeloc >> 16);
700	n/a	/* jr $25 */
701	n/a	tramp[3] = 0x03200008;
702	n/a	/* ori $12,low(codeloc) */
703	n/a	tramp[4] = 0x358c0000 \| ((unsigned)codeloc & 0xffff);
704	n/a	#else
705	n/a	/* N64 has a somewhat larger trampoline. */
706	n/a	/* lui $25,high(fn) */
707	n/a	tramp[0] = 0x3c190000 \| ((unsigned long)fn >> 48);
708	n/a	/* lui $12,high(codeloc) */
709	n/a	tramp[1] = 0x3c0c0000 \| ((unsigned long)codeloc >> 48);
710	n/a	/* ori $25,mid-high(fn) */
711	n/a	tramp[2] = 0x37390000 \| (((unsigned long)fn >> 32 ) & 0xffff);
712	n/a	/* ori $12,mid-high(codeloc) */
713	n/a	tramp[3] = 0x358c0000 \| (((unsigned long)codeloc >> 32) & 0xffff);
714	n/a	/* dsll $25,$25,16 */
715	n/a	tramp[4] = 0x0019cc38;
716	n/a	/* dsll $12,$12,16 */
717	n/a	tramp[5] = 0x000c6438;
718	n/a	/* ori $25,mid-low(fn) */
719	n/a	tramp[6] = 0x37390000 \| (((unsigned long)fn >> 16 ) & 0xffff);
720	n/a	/* ori $12,mid-low(codeloc) */
721	n/a	tramp[7] = 0x358c0000 \| (((unsigned long)codeloc >> 16) & 0xffff);
722	n/a	/* dsll $25,$25,16 */
723	n/a	tramp[8] = 0x0019cc38;
724	n/a	/* dsll $12,$12,16 */
725	n/a	tramp[9] = 0x000c6438;
726	n/a	/* ori $25,low(fn) */
727	n/a	tramp[10] = 0x37390000 \| ((unsigned long)fn & 0xffff);
728	n/a	/* jr $25 */
729	n/a	tramp[11] = 0x03200008;
730	n/a	/* ori $12,low(codeloc) */
731	n/a	tramp[12] = 0x358c0000 \| ((unsigned long)codeloc & 0xffff);
732	n/a
733	n/a	#endif
734	n/a
735	n/a	closure->cif = cif;
736	n/a	closure->fun = fun;
737	n/a	closure->user_data = user_data;
738	n/a
739	n/a	#ifdef USE__BUILTIN___CLEAR_CACHE
740	n/a	__builtin___clear_cache(clear_location, clear_location + FFI_TRAMPOLINE_SIZE);
741	n/a	#else
742	n/a	cacheflush (clear_location, FFI_TRAMPOLINE_SIZE, ICACHE);
743	n/a	#endif
744	n/a	return FFI_OK;
745	n/a	}
746	n/a
747	n/a	/*
748	n/a	* Decodes the arguments to a function, which will be stored on the
749	n/a	* stack. AR is the pointer to the beginning of the integer arguments
750	n/a	* (and, depending upon the arguments, some floating-point arguments
751	n/a	* as well). FPR is a pointer to the area where floating point
752	n/a	* registers have been saved, if any.
753	n/a	*
754	n/a	* RVALUE is the location where the function return value will be
755	n/a	* stored. CLOSURE is the prepared closure to invoke.
756	n/a	*
757	n/a	* This function should only be called from assembly, which is in
758	n/a	* turn called from a trampoline.
759	n/a	*
760	n/a	* Returns the function return type.
761	n/a	*
762	n/a	* Based on the similar routine for sparc.
763	n/a	*/
764	n/a	int
765	n/a	ffi_closure_mips_inner_O32 (ffi_closure *closure,
766	n/a	void rvalue, ffi_arg ar,
767	n/a	double *fpr)
768	n/a	{
769	n/a	ffi_cif *cif;
770	n/a	void **avaluep;
771	n/a	ffi_arg *avalue;
772	n/a	ffi_type **arg_types;
773	n/a	int i, avn, argn, seen_int;
774	n/a
775	n/a	cif = closure->cif;
776	n/a	avalue = alloca (cif->nargs * sizeof (ffi_arg));
777	n/a	avaluep = alloca (cif->nargs * sizeof (ffi_arg));
778	n/a
779	n/a	seen_int = (cif->abi == FFI_O32_SOFT_FLOAT);
780	n/a	argn = 0;
781	n/a
782	n/a	if ((cif->flags >> (FFI_FLAG_BITS * 2)) == FFI_TYPE_STRUCT)
783	n/a	{
784	n/a	rvalue = (void *)(UINT32)ar[0];
785	n/a	argn = 1;
786	n/a	}
787	n/a
788	n/a	i = 0;
789	n/a	avn = cif->nargs;
790	n/a	arg_types = cif->arg_types;
791	n/a
792	n/a	while (i < avn)
793	n/a	{
794	n/a	if (i < 2 && !seen_int &&
795	n/a	(arg_types[i]->type == FFI_TYPE_FLOAT \|\|
796	n/a	arg_types[i]->type == FFI_TYPE_DOUBLE \|\|
797	n/a	arg_types[i]->type == FFI_TYPE_LONGDOUBLE))
798	n/a	{
799	n/a	#if defined(__MIPSEB__) \|\| defined(_MIPSEB)
800	n/a	if (arg_types[i]->type == FFI_TYPE_FLOAT)
801	n/a	avaluep[i] = ((char *) &fpr[i]) + sizeof (float);
802	n/a	else
803	n/a	#endif
804	n/a	avaluep[i] = (char *) &fpr[i];
805	n/a	}
806	n/a	else
807	n/a	{
808	n/a	if (arg_types[i]->alignment == 8 && (argn & 0x1))
809	n/a	argn++;
810	n/a	switch (arg_types[i]->type)
811	n/a	{
812	n/a	case FFI_TYPE_SINT8:
813	n/a	avaluep[i] = &avalue[i];
814	n/a	(SINT8 ) &avalue[i] = (SINT8) ar[argn];
815	n/a	break;
816	n/a
817	n/a	case FFI_TYPE_UINT8:
818	n/a	avaluep[i] = &avalue[i];
819	n/a	(UINT8 ) &avalue[i] = (UINT8) ar[argn];
820	n/a	break;
821	n/a
822	n/a	case FFI_TYPE_SINT16:
823	n/a	avaluep[i] = &avalue[i];
824	n/a	(SINT16 ) &avalue[i] = (SINT16) ar[argn];
825	n/a	break;
826	n/a
827	n/a	case FFI_TYPE_UINT16:
828	n/a	avaluep[i] = &avalue[i];
829	n/a	(UINT16 ) &avalue[i] = (UINT16) ar[argn];
830	n/a	break;
831	n/a
832	n/a	default:
833	n/a	avaluep[i] = (char *) &ar[argn];
834	n/a	break;
835	n/a	}
836	n/a	seen_int = 1;
837	n/a	}
838	n/a	argn += ALIGN(arg_types[i]->size, FFI_SIZEOF_ARG) / FFI_SIZEOF_ARG;
839	n/a	i++;
840	n/a	}
841	n/a
842	n/a	/* Invoke the closure. */
843	n/a	(closure->fun) (cif, rvalue, avaluep, closure->user_data);
844	n/a
845	n/a	if (cif->abi == FFI_O32_SOFT_FLOAT)
846	n/a	{
847	n/a	switch (cif->rtype->type)
848	n/a	{
849	n/a	case FFI_TYPE_FLOAT:
850	n/a	return FFI_TYPE_INT;
851	n/a	case FFI_TYPE_DOUBLE:
852	n/a	return FFI_TYPE_UINT64;
853	n/a	default:
854	n/a	return cif->rtype->type;
855	n/a	}
856	n/a	}
857	n/a	else
858	n/a	{
859	n/a	return cif->rtype->type;
860	n/a	}
861	n/a	}
862	n/a
863	n/a	#if defined(FFI_MIPS_N32)
864	n/a
865	n/a	static void
866	n/a	copy_struct_N32(char target, unsigned offset, ffi_abi abi, ffi_type type,
867	n/a	int argn, unsigned arg_offset, ffi_arg *ar,
868	n/a	ffi_arg *fpr, int soft_float)
869	n/a	{
870	n/a	ffi_type **elt_typep = type->elements;
871	n/a	while(*elt_typep)
872	n/a	{
873	n/a	ffi_type elt_type = elt_typep;
874	n/a	unsigned o;
875	n/a	char *tp;
876	n/a	char *argp;
877	n/a	char *fpp;
878	n/a
879	n/a	o = ALIGN(offset, elt_type->alignment);
880	n/a	arg_offset += o - offset;
881	n/a	offset = o;
882	n/a	argn += arg_offset / sizeof(ffi_arg);
883	n/a	arg_offset = arg_offset % sizeof(ffi_arg);
884	n/a
885	n/a	argp = (char *)(ar + argn);
886	n/a	fpp = (char *)(argn >= 8 ? ar + argn : fpr + argn);
887	n/a
888	n/a	tp = target + offset;
889	n/a
890	n/a	if (elt_type->type == FFI_TYPE_DOUBLE && !soft_float)
891	n/a	(double )tp = (double )fpp;
892	n/a	else
893	n/a	memcpy(tp, argp + arg_offset, elt_type->size);
894	n/a
895	n/a	offset += elt_type->size;
896	n/a	arg_offset += elt_type->size;
897	n/a	elt_typep++;
898	n/a	argn += arg_offset / sizeof(ffi_arg);
899	n/a	arg_offset = arg_offset % sizeof(ffi_arg);
900	n/a	}
901	n/a	}
902	n/a
903	n/a	/*
904	n/a	* Decodes the arguments to a function, which will be stored on the
905	n/a	* stack. AR is the pointer to the beginning of the integer
906	n/a	* arguments. FPR is a pointer to the area where floating point
907	n/a	* registers have been saved.
908	n/a	*
909	n/a	* RVALUE is the location where the function return value will be
910	n/a	* stored. CLOSURE is the prepared closure to invoke.
911	n/a	*
912	n/a	* This function should only be called from assembly, which is in
913	n/a	* turn called from a trampoline.
914	n/a	*
915	n/a	* Returns the function return flags.
916	n/a	*
917	n/a	*/
918	n/a	int
919	n/a	ffi_closure_mips_inner_N32 (ffi_closure *closure,
920	n/a	void rvalue, ffi_arg ar,
921	n/a	ffi_arg *fpr)
922	n/a	{
923	n/a	ffi_cif *cif;
924	n/a	void **avaluep;
925	n/a	ffi_arg *avalue;
926	n/a	ffi_type **arg_types;
927	n/a	int i, avn, argn;
928	n/a	int soft_float;
929	n/a	ffi_arg *argp;
930	n/a
931	n/a	cif = closure->cif;
932	n/a	soft_float = cif->abi == FFI_N64_SOFT_FLOAT
933	n/a	\|\| cif->abi == FFI_N32_SOFT_FLOAT;
934	n/a	avalue = alloca (cif->nargs * sizeof (ffi_arg));
935	n/a	avaluep = alloca (cif->nargs * sizeof (ffi_arg));
936	n/a
937	n/a	argn = 0;
938	n/a
939	n/a	if (cif->rstruct_flag)
940	n/a	{
941	n/a	#if _MIPS_SIM==_ABIN32
942	n/a	rvalue = (void *)(UINT32)ar[0];
943	n/a	#else /* N64 */
944	n/a	rvalue = (void *)ar[0];
945	n/a	#endif
946	n/a	argn = 1;
947	n/a	}
948	n/a
949	n/a	i = 0;
950	n/a	avn = cif->nargs;
951	n/a	arg_types = cif->arg_types;
952	n/a
953	n/a	while (i < avn)
954	n/a	{
955	n/a	if (arg_types[i]->type == FFI_TYPE_FLOAT
956	n/a	\|\| arg_types[i]->type == FFI_TYPE_DOUBLE
957	n/a	\|\| arg_types[i]->type == FFI_TYPE_LONGDOUBLE)
958	n/a	{
959	n/a	argp = (argn >= 8 \|\| soft_float) ? ar + argn : fpr + argn;
960	n/a	if ((arg_types[i]->type == FFI_TYPE_LONGDOUBLE) && ((unsigned)argp & (arg_types[i]->alignment-1)))
961	n/a	{
962	n/a	argp=(ffi_arg*)ALIGN(argp,arg_types[i]->alignment);
963	n/a	argn++;
964	n/a	}
965	n/a	#if defined(__MIPSEB__) \|\| defined(_MIPSEB)
966	n/a	if (arg_types[i]->type == FFI_TYPE_FLOAT && argn < 8)
967	n/a	avaluep[i] = ((char *) argp) + sizeof (float);
968	n/a	else
969	n/a	#endif
970	n/a	avaluep[i] = (char *) argp;
971	n/a	}
972	n/a	else
973	n/a	{
974	n/a	unsigned type = arg_types[i]->type;
975	n/a
976	n/a	if (arg_types[i]->alignment > sizeof(ffi_arg))
977	n/a	argn = ALIGN(argn, arg_types[i]->alignment / sizeof(ffi_arg));
978	n/a
979	n/a	argp = ar + argn;
980	n/a
981	n/a	/* The size of a pointer depends on the ABI */
982	n/a	if (type == FFI_TYPE_POINTER)
983	n/a	type = (cif->abi == FFI_N64 \|\| cif->abi == FFI_N64_SOFT_FLOAT)
984	n/a	? FFI_TYPE_SINT64 : FFI_TYPE_SINT32;
985	n/a
986	n/a	if (soft_float && type == FFI_TYPE_FLOAT)
987	n/a	type = FFI_TYPE_UINT32;
988	n/a
989	n/a	switch (type)
990	n/a	{
991	n/a	case FFI_TYPE_SINT8:
992	n/a	avaluep[i] = &avalue[i];
993	n/a	(SINT8 ) &avalue[i] = (SINT8) *argp;
994	n/a	break;
995	n/a
996	n/a	case FFI_TYPE_UINT8:
997	n/a	avaluep[i] = &avalue[i];
998	n/a	(UINT8 ) &avalue[i] = (UINT8) *argp;
999	n/a	break;
1000	n/a
1001	n/a	case FFI_TYPE_SINT16:
1002	n/a	avaluep[i] = &avalue[i];
1003	n/a	(SINT16 ) &avalue[i] = (SINT16) *argp;
1004	n/a	break;
1005	n/a
1006	n/a	case FFI_TYPE_UINT16:
1007	n/a	avaluep[i] = &avalue[i];
1008	n/a	(UINT16 ) &avalue[i] = (UINT16) *argp;
1009	n/a	break;
1010	n/a
1011	n/a	case FFI_TYPE_SINT32:
1012	n/a	avaluep[i] = &avalue[i];
1013	n/a	(SINT32 ) &avalue[i] = (SINT32) *argp;
1014	n/a	break;
1015	n/a
1016	n/a	case FFI_TYPE_UINT32:
1017	n/a	avaluep[i] = &avalue[i];
1018	n/a	(UINT32 ) &avalue[i] = (UINT32) *argp;
1019	n/a	break;
1020	n/a
1021	n/a	case FFI_TYPE_STRUCT:
1022	n/a	if (argn < 8)
1023	n/a	{
1024	n/a	/* Allocate space for the struct as at least part of
1025	n/a	it was passed in registers. */
1026	n/a	avaluep[i] = alloca(arg_types[i]->size);
1027	n/a	copy_struct_N32(avaluep[i], 0, cif->abi, arg_types[i],
1028	n/a	argn, 0, ar, fpr, soft_float);
1029	n/a
1030	n/a	break;
1031	n/a	}
1032	n/a	/* Else fall through. */
1033	n/a	default:
1034	n/a	avaluep[i] = (char *) argp;
1035	n/a	break;
1036	n/a	}
1037	n/a	}
1038	n/a	argn += ALIGN(arg_types[i]->size, sizeof(ffi_arg)) / sizeof(ffi_arg);
1039	n/a	i++;
1040	n/a	}
1041	n/a
1042	n/a	/* Invoke the closure. */
1043	n/a	(closure->fun) (cif, rvalue, avaluep, closure->user_data);
1044	n/a
1045	n/a	return cif->flags >> (FFI_FLAG_BITS * 8);
1046	n/a	}
1047	n/a
1048	n/a	#endif /* FFI_MIPS_N32 */
1049	n/a
1050	n/a	#endif /* FFI_CLOSURES */