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

#	count	content
1	n/a	/* -----------------------------------------------------------------------
2	n/a	ffi.c - Copyright (c) 2011, 2013 Anthony Green
3	n/a	Copyright (c) 1996, 2003-2004, 2007-2008 Red Hat, Inc.
4	n/a
5	n/a	SPARC Foreign Function Interface
6	n/a
7	n/a	Permission is hereby granted, free of charge, to any person obtaining
8	n/a	a copy of this software and associated documentation files (the
9	n/a	``Software''), to deal in the Software without restriction, including
10	n/a	without limitation the rights to use, copy, modify, merge, publish,
11	n/a	distribute, sublicense, and/or sell copies of the Software, and to
12	n/a	permit persons to whom the Software is furnished to do so, subject to
13	n/a	the following conditions:
14	n/a
15	n/a	The above copyright notice and this permission notice shall be included
16	n/a	in all copies or substantial portions of the Software.
17	n/a
18	n/a	THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
19	n/a	EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20	n/a	MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
21	n/a	NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
22	n/a	HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
23	n/a	WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24	n/a	OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
25	n/a	DEALINGS IN THE SOFTWARE.
26	n/a	----------------------------------------------------------------------- */
27	n/a
28	n/a	#include <ffi.h>
29	n/a	#include <ffi_common.h>
30	n/a
31	n/a	#include <stdlib.h>
32	n/a
33	n/a
34	n/a	/* ffi_prep_args is called by the assembly routine once stack space
35	n/a	has been allocated for the function's arguments */
36	n/a
37	n/a	void ffi_prep_args_v8(char stack, extended_cif ecif)
38	n/a	{
39	n/a	int i;
40	n/a	void **p_argv;
41	n/a	char *argp;
42	n/a	ffi_type **p_arg;
43	n/a
44	n/a	/* Skip 16 words for the window save area */
45	n/a	argp = stack + 16*sizeof(int);
46	n/a
47	n/a	/* This should only really be done when we are returning a structure,
48	n/a	however, it's faster just to do it all the time...
49	n/a
50	n/a	if ( ecif->cif->rtype->type == FFI_TYPE_STRUCT ) */
51	n/a	(int ) argp = (long)ecif->rvalue;
52	n/a
53	n/a	/* And 1 word for the structure return value. */
54	n/a	argp += sizeof(int);
55	n/a
56	n/a	#ifdef USING_PURIFY
57	n/a	/* Purify will probably complain in our assembly routine, unless we
58	n/a	zero out this memory. */
59	n/a
60	n/a	((int*)argp)[0] = 0;
61	n/a	((int*)argp)[1] = 0;
62	n/a	((int*)argp)[2] = 0;
63	n/a	((int*)argp)[3] = 0;
64	n/a	((int*)argp)[4] = 0;
65	n/a	((int*)argp)[5] = 0;
66	n/a	#endif
67	n/a
68	n/a	p_argv = ecif->avalue;
69	n/a
70	n/a	for (i = ecif->cif->nargs, p_arg = ecif->cif->arg_types; i; i--, p_arg++)
71	n/a	{
72	n/a	size_t z;
73	n/a
74	n/a	if ((*p_arg)->type == FFI_TYPE_STRUCT
75	n/a	#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
76	n/a	\|\| (*p_arg)->type == FFI_TYPE_LONGDOUBLE
77	n/a	#endif
78	n/a	)
79	n/a	{
80	n/a	(unsigned int ) argp = (unsigned long)(* p_argv);
81	n/a	z = sizeof(int);
82	n/a	}
83	n/a	else
84	n/a	{
85	n/a	z = (*p_arg)->size;
86	n/a	if (z < sizeof(int))
87	n/a	{
88	n/a	z = sizeof(int);
89	n/a	switch ((*p_arg)->type)
90	n/a	{
91	n/a	case FFI_TYPE_SINT8:
92	n/a	(signed int ) argp = (SINT8 )(* p_argv);
93	n/a	break;
94	n/a
95	n/a	case FFI_TYPE_UINT8:
96	n/a	(unsigned int ) argp = (UINT8 )(* p_argv);
97	n/a	break;
98	n/a
99	n/a	case FFI_TYPE_SINT16:
100	n/a	(signed int ) argp = (SINT16 )(* p_argv);
101	n/a	break;
102	n/a
103	n/a	case FFI_TYPE_UINT16:
104	n/a	(unsigned int ) argp = (UINT16 )(* p_argv);
105	n/a	break;
106	n/a
107	n/a	default:
108	n/a	FFI_ASSERT(0);
109	n/a	}
110	n/a	}
111	n/a	else
112	n/a	{
113	n/a	memcpy(argp, *p_argv, z);
114	n/a	}
115	n/a	}
116	n/a	p_argv++;
117	n/a	argp += z;
118	n/a	}
119	n/a
120	n/a	return;
121	n/a	}
122	n/a
123	n/a	int ffi_prep_args_v9(char stack, extended_cif ecif)
124	n/a	{
125	n/a	int i, ret = 0;
126	n/a	int tmp;
127	n/a	void **p_argv;
128	n/a	char *argp;
129	n/a	ffi_type **p_arg;
130	n/a
131	n/a	tmp = 0;
132	n/a
133	n/a	/* Skip 16 words for the window save area */
134	n/a	argp = stack + 16*sizeof(long long);
135	n/a
136	n/a	#ifdef USING_PURIFY
137	n/a	/* Purify will probably complain in our assembly routine, unless we
138	n/a	zero out this memory. */
139	n/a
140	n/a	((long long*)argp)[0] = 0;
141	n/a	((long long*)argp)[1] = 0;
142	n/a	((long long*)argp)[2] = 0;
143	n/a	((long long*)argp)[3] = 0;
144	n/a	((long long*)argp)[4] = 0;
145	n/a	((long long*)argp)[5] = 0;
146	n/a	#endif
147	n/a
148	n/a	p_argv = ecif->avalue;
149	n/a
150	n/a	if (ecif->cif->rtype->type == FFI_TYPE_STRUCT &&
151	n/a	ecif->cif->rtype->size > 32)
152	n/a	{
153	n/a	(unsigned long long ) argp = (unsigned long)ecif->rvalue;
154	n/a	argp += sizeof(long long);
155	n/a	tmp = 1;
156	n/a	}
157	n/a
158	n/a	for (i = 0, p_arg = ecif->cif->arg_types; i < ecif->cif->nargs;
159	n/a	i++, p_arg++)
160	n/a	{
161	n/a	size_t z;
162	n/a
163	n/a	z = (*p_arg)->size;
164	n/a	switch ((*p_arg)->type)
165	n/a	{
166	n/a	case FFI_TYPE_STRUCT:
167	n/a	if (z > 16)
168	n/a	{
169	n/a	/* For structures larger than 16 bytes we pass reference. */
170	n/a	(unsigned long long ) argp = (unsigned long)* p_argv;
171	n/a	argp += sizeof(long long);
172	n/a	tmp++;
173	n/a	p_argv++;
174	n/a	continue;
175	n/a	}
176	n/a	/* FALLTHROUGH */
177	n/a	case FFI_TYPE_FLOAT:
178	n/a	case FFI_TYPE_DOUBLE:
179	n/a	#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
180	n/a	case FFI_TYPE_LONGDOUBLE:
181	n/a	#endif
182	n/a	ret = 1; /* We should promote into FP regs as well as integer. */
183	n/a	break;
184	n/a	}
185	n/a	if (z < sizeof(long long))
186	n/a	{
187	n/a	switch ((*p_arg)->type)
188	n/a	{
189	n/a	case FFI_TYPE_SINT8:
190	n/a	(signed long long ) argp = (SINT8 )(* p_argv);
191	n/a	break;
192	n/a
193	n/a	case FFI_TYPE_UINT8:
194	n/a	(unsigned long long ) argp = (UINT8 )(* p_argv);
195	n/a	break;
196	n/a
197	n/a	case FFI_TYPE_SINT16:
198	n/a	(signed long long ) argp = (SINT16 )(* p_argv);
199	n/a	break;
200	n/a
201	n/a	case FFI_TYPE_UINT16:
202	n/a	(unsigned long long ) argp = (UINT16 )(* p_argv);
203	n/a	break;
204	n/a
205	n/a	case FFI_TYPE_SINT32:
206	n/a	(signed long long ) argp = (SINT32 )(* p_argv);
207	n/a	break;
208	n/a
209	n/a	case FFI_TYPE_UINT32:
210	n/a	(unsigned long long ) argp = (UINT32 )(* p_argv);
211	n/a	break;
212	n/a
213	n/a	case FFI_TYPE_FLOAT:
214	n/a	(float ) (argp + 4) = (FLOAT32 )(* p_argv); /* Right justify */
215	n/a	break;
216	n/a
217	n/a	case FFI_TYPE_STRUCT:
218	n/a	memcpy(argp, *p_argv, z);
219	n/a	break;
220	n/a
221	n/a	default:
222	n/a	FFI_ASSERT(0);
223	n/a	}
224	n/a	z = sizeof(long long);
225	n/a	tmp++;
226	n/a	}
227	n/a	else if (z == sizeof(long long))
228	n/a	{
229	n/a	memcpy(argp, *p_argv, z);
230	n/a	z = sizeof(long long);
231	n/a	tmp++;
232	n/a	}
233	n/a	else
234	n/a	{
235	n/a	if ((tmp & 1) && (*p_arg)->alignment > 8)
236	n/a	{
237	n/a	tmp++;
238	n/a	argp += sizeof(long long);
239	n/a	}
240	n/a	memcpy(argp, *p_argv, z);
241	n/a	z = 2 * sizeof(long long);
242	n/a	tmp += 2;
243	n/a	}
244	n/a	p_argv++;
245	n/a	argp += z;
246	n/a	}
247	n/a
248	n/a	return ret;
249	n/a	}
250	n/a
251	n/a	/* Perform machine dependent cif processing */
252	n/a	ffi_status ffi_prep_cif_machdep(ffi_cif *cif)
253	n/a	{
254	n/a	int wordsize;
255	n/a
256	n/a	if (cif->abi != FFI_V9)
257	n/a	{
258	n/a	wordsize = 4;
259	n/a
260	n/a	/* If we are returning a struct, this will already have been added.
261	n/a	Otherwise we need to add it because it's always got to be there! */
262	n/a
263	n/a	if (cif->rtype->type != FFI_TYPE_STRUCT)
264	n/a	cif->bytes += wordsize;
265	n/a
266	n/a	/* sparc call frames require that space is allocated for 6 args,
267	n/a	even if they aren't used. Make that space if necessary. */
268	n/a
269	n/a	if (cif->bytes < 4*6+4)
270	n/a	cif->bytes = 4*6+4;
271	n/a	}
272	n/a	else
273	n/a	{
274	n/a	wordsize = 8;
275	n/a
276	n/a	/* sparc call frames require that space is allocated for 6 args,
277	n/a	even if they aren't used. Make that space if necessary. */
278	n/a
279	n/a	if (cif->bytes < 8*6)
280	n/a	cif->bytes = 8*6;
281	n/a	}
282	n/a
283	n/a	/* Adjust cif->bytes. to include 16 words for the window save area,
284	n/a	and maybe the struct/union return pointer area, */
285	n/a
286	n/a	cif->bytes += 16 * wordsize;
287	n/a
288	n/a	/* The stack must be 2 word aligned, so round bytes up
289	n/a	appropriately. */
290	n/a
291	n/a	cif->bytes = ALIGN(cif->bytes, 2 * wordsize);
292	n/a
293	n/a	/* Set the return type flag */
294	n/a	switch (cif->rtype->type)
295	n/a	{
296	n/a	case FFI_TYPE_VOID:
297	n/a	case FFI_TYPE_FLOAT:
298	n/a	case FFI_TYPE_DOUBLE:
299	n/a	#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
300	n/a	case FFI_TYPE_LONGDOUBLE:
301	n/a	#endif
302	n/a	cif->flags = cif->rtype->type;
303	n/a	break;
304	n/a
305	n/a	case FFI_TYPE_STRUCT:
306	n/a	if (cif->abi == FFI_V9 && cif->rtype->size > 32)
307	n/a	cif->flags = FFI_TYPE_VOID;
308	n/a	else
309	n/a	cif->flags = FFI_TYPE_STRUCT;
310	n/a	break;
311	n/a
312	n/a	case FFI_TYPE_SINT8:
313	n/a	case FFI_TYPE_UINT8:
314	n/a	case FFI_TYPE_SINT16:
315	n/a	case FFI_TYPE_UINT16:
316	n/a	if (cif->abi == FFI_V9)
317	n/a	cif->flags = FFI_TYPE_INT;
318	n/a	else
319	n/a	cif->flags = cif->rtype->type;
320	n/a	break;
321	n/a
322	n/a	case FFI_TYPE_SINT64:
323	n/a	case FFI_TYPE_UINT64:
324	n/a	if (cif->abi == FFI_V9)
325	n/a	cif->flags = FFI_TYPE_INT;
326	n/a	else
327	n/a	cif->flags = FFI_TYPE_SINT64;
328	n/a	break;
329	n/a
330	n/a	default:
331	n/a	cif->flags = FFI_TYPE_INT;
332	n/a	break;
333	n/a	}
334	n/a	return FFI_OK;
335	n/a	}
336	n/a
337	n/a	int ffi_v9_layout_struct(ffi_type arg, int off, char ret, char intg, char flt)
338	n/a	{
339	n/a	ffi_type **ptr = &arg->elements[0];
340	n/a
341	n/a	while (*ptr != NULL)
342	n/a	{
343	n/a	if (off & ((*ptr)->alignment - 1))
344	n/a	off = ALIGN(off, (*ptr)->alignment);
345	n/a
346	n/a	switch ((*ptr)->type)
347	n/a	{
348	n/a	case FFI_TYPE_STRUCT:
349	n/a	off = ffi_v9_layout_struct(*ptr, off, ret, intg, flt);
350	n/a	off = ALIGN(off, FFI_SIZEOF_ARG);
351	n/a	break;
352	n/a	case FFI_TYPE_FLOAT:
353	n/a	case FFI_TYPE_DOUBLE:
354	n/a	#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
355	n/a	case FFI_TYPE_LONGDOUBLE:
356	n/a	#endif
357	n/a	memmove(ret + off, flt + off, (*ptr)->size);
358	n/a	off += (*ptr)->size;
359	n/a	break;
360	n/a	default:
361	n/a	memmove(ret + off, intg + off, (*ptr)->size);
362	n/a	off += (*ptr)->size;
363	n/a	break;
364	n/a	}
365	n/a	ptr++;
366	n/a	}
367	n/a	return off;
368	n/a	}
369	n/a
370	n/a
371	n/a	#ifdef SPARC64
372	n/a	extern int ffi_call_v9(void , extended_cif , unsigned,
373	n/a	unsigned, unsigned , void (fn)(void));
374	n/a	#else
375	n/a	extern int ffi_call_v8(void , extended_cif , unsigned,
376	n/a	unsigned, unsigned , void (fn)(void));
377	n/a	#endif
378	n/a
379	n/a	#ifndef __GNUC__
380	n/a	void ffi_flush_icache (void *, size_t);
381	n/a	#endif
382	n/a
383	n/a	void ffi_call(ffi_cif cif, void (fn)(void), void rvalue, void *avalue)
384	n/a	{
385	n/a	extended_cif ecif;
386	n/a	void *rval = rvalue;
387	n/a
388	n/a	ecif.cif = cif;
389	n/a	ecif.avalue = avalue;
390	n/a
391	n/a	/* If the return value is a struct and we don't have a return */
392	n/a	/* value address then we need to make one */
393	n/a
394	n/a	ecif.rvalue = rvalue;
395	n/a	if (cif->rtype->type == FFI_TYPE_STRUCT)
396	n/a	{
397	n/a	if (cif->rtype->size <= 32)
398	n/a	rval = alloca(64);
399	n/a	else
400	n/a	{
401	n/a	rval = NULL;
402	n/a	if (rvalue == NULL)
403	n/a	ecif.rvalue = alloca(cif->rtype->size);
404	n/a	}
405	n/a	}
406	n/a
407	n/a	switch (cif->abi)
408	n/a	{
409	n/a	case FFI_V8:
410	n/a	#ifdef SPARC64
411	n/a	/* We don't yet support calling 32bit code from 64bit */
412	n/a	FFI_ASSERT(0);
413	n/a	#else
414	n/a	if (rvalue && (cif->rtype->type == FFI_TYPE_STRUCT
415	n/a	#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
416	n/a	\|\| cif->flags == FFI_TYPE_LONGDOUBLE
417	n/a	#endif
418	n/a	))
419	n/a	{
420	n/a	/* For v8, we need an "unimp" with size of returning struct */
421	n/a	/* behind "call", so we alloc some executable space for it. */
422	n/a	/* l7 is used, we need to make sure v8.S doesn't use %l7. */
423	n/a	unsigned int *call_struct = NULL;
424	n/a	ffi_closure_alloc(32, (void **)&call_struct);
425	n/a	if (call_struct)
426	n/a	{
427	n/a	unsigned long f = (unsigned long)fn;
428	n/a	call_struct[0] = 0xae10001f; /* mov %i7, %l7 */
429	n/a	call_struct[1] = 0xbe10000f; /* mov %o7, %i7 */
430	n/a	call_struct[2] = 0x03000000 \| f >> 10; /* sethi %hi(fn), %g1 */
431	n/a	call_struct[3] = 0x9fc06000 \| (f & 0x3ff); /* jmp %g1+%lo(fn), %o7 */
432	n/a	call_struct[4] = 0x01000000; /* nop */
433	n/a	if (cif->rtype->size < 0x7f)
434	n/a	call_struct[5] = cif->rtype->size; /* unimp */
435	n/a	else
436	n/a	call_struct[5] = 0x01000000; /* nop */
437	n/a	call_struct[6] = 0x81c7e008; /* ret */
438	n/a	call_struct[7] = 0xbe100017; /* mov %l7, %i7 */
439	n/a	#ifdef __GNUC__
440	n/a	asm volatile ("iflush %0; iflush %0+8; iflush %0+16; iflush %0+24" : :
441	n/a	"r" (call_struct) : "memory");
442	n/a	/* SPARC v8 requires 5 instructions for flush to be visible */
443	n/a	asm volatile ("nop; nop; nop; nop; nop");
444	n/a	#else
445	n/a	ffi_flush_icache (call_struct, 32);
446	n/a	#endif
447	n/a	ffi_call_v8(ffi_prep_args_v8, &ecif, cif->bytes,
448	n/a	cif->flags, rvalue, call_struct);
449	n/a	ffi_closure_free(call_struct);
450	n/a	}
451	n/a	else
452	n/a	{
453	n/a	ffi_call_v8(ffi_prep_args_v8, &ecif, cif->bytes,
454	n/a	cif->flags, rvalue, fn);
455	n/a	}
456	n/a	}
457	n/a	else
458	n/a	{
459	n/a	ffi_call_v8(ffi_prep_args_v8, &ecif, cif->bytes,
460	n/a	cif->flags, rvalue, fn);
461	n/a	}
462	n/a	#endif
463	n/a	break;
464	n/a	case FFI_V9:
465	n/a	#ifdef SPARC64
466	n/a	ffi_call_v9(ffi_prep_args_v9, &ecif, cif->bytes,
467	n/a	cif->flags, rval, fn);
468	n/a	if (rvalue && rval && cif->rtype->type == FFI_TYPE_STRUCT)
469	n/a	ffi_v9_layout_struct(cif->rtype, 0, (char )rvalue, (char )rval, ((char *)rval)+32);
470	n/a	#else
471	n/a	/* And vice versa */
472	n/a	FFI_ASSERT(0);
473	n/a	#endif
474	n/a	break;
475	n/a	default:
476	n/a	FFI_ASSERT(0);
477	n/a	break;
478	n/a	}
479	n/a	}
480	n/a
481	n/a
482	n/a	#ifdef SPARC64
483	n/a	extern void ffi_closure_v9(void);
484	n/a	#else
485	n/a	extern void ffi_closure_v8(void);
486	n/a	#endif
487	n/a
488	n/a	ffi_status
489	n/a	ffi_prep_closure_loc (ffi_closure* closure,
490	n/a	ffi_cif* cif,
491	n/a	void (fun)(ffi_cif, void, void, void),
492	n/a	void *user_data,
493	n/a	void *codeloc)
494	n/a	{
495	n/a	unsigned int tramp = (unsigned int ) &closure->tramp[0];
496	n/a	unsigned long fn;
497	n/a	#ifdef SPARC64
498	n/a	/* Trampoline address is equal to the closure address. We take advantage
499	n/a	of that to reduce the trampoline size by 8 bytes. */
500	n/a	if (cif->abi != FFI_V9)
501	n/a	return FFI_BAD_ABI;
502	n/a	fn = (unsigned long) ffi_closure_v9;
503	n/a	tramp[0] = 0x83414000; /* rd %pc, %g1 */
504	n/a	tramp[1] = 0xca586010; /* ldx [%g1+16], %g5 */
505	n/a	tramp[2] = 0x81c14000; /* jmp %g5 */
506	n/a	tramp[3] = 0x01000000; /* nop */
507	n/a	((unsigned long ) &tramp[4]) = fn;
508	n/a	#else
509	n/a	unsigned long ctx = (unsigned long) codeloc;
510	n/a	if (cif->abi != FFI_V8)
511	n/a	return FFI_BAD_ABI;
512	n/a	fn = (unsigned long) ffi_closure_v8;
513	n/a	tramp[0] = 0x03000000 \| fn >> 10; /* sethi %hi(fn), %g1 */
514	n/a	tramp[1] = 0x05000000 \| ctx >> 10; /* sethi %hi(ctx), %g2 */
515	n/a	tramp[2] = 0x81c06000 \| (fn & 0x3ff); /* jmp %g1+%lo(fn) */
516	n/a	tramp[3] = 0x8410a000 \| (ctx & 0x3ff);/* or %g2, %lo(ctx) */
517	n/a	#endif
518	n/a
519	n/a	closure->cif = cif;
520	n/a	closure->fun = fun;
521	n/a	closure->user_data = user_data;
522	n/a
523	n/a	/* Flush the Icache. closure is 8 bytes aligned. */
524	n/a	#ifdef __GNUC__
525	n/a	#ifdef SPARC64
526	n/a	asm volatile ("flush %0; flush %0+8" : : "r" (closure) : "memory");
527	n/a	#else
528	n/a	asm volatile ("iflush %0; iflush %0+8" : : "r" (closure) : "memory");
529	n/a	/* SPARC v8 requires 5 instructions for flush to be visible */
530	n/a	asm volatile ("nop; nop; nop; nop; nop");
531	n/a	#endif
532	n/a	#else
533	n/a	ffi_flush_icache (closure, 16);
534	n/a	#endif
535	n/a
536	n/a	return FFI_OK;
537	n/a	}
538	n/a
539	n/a	int
540	n/a	ffi_closure_sparc_inner_v8(ffi_closure *closure,
541	n/a	void rvalue, unsigned long gpr, unsigned long *scratch)
542	n/a	{
543	n/a	ffi_cif *cif;
544	n/a	ffi_type **arg_types;
545	n/a	void **avalue;
546	n/a	int i, argn;
547	n/a
548	n/a	cif = closure->cif;
549	n/a	arg_types = cif->arg_types;
550	n/a	avalue = alloca(cif->nargs * sizeof(void *));
551	n/a
552	n/a	/* Copy the caller's structure return address so that the closure
553	n/a	returns the data directly to the caller. */
554	n/a	if (cif->flags == FFI_TYPE_STRUCT
555	n/a	#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
556	n/a	\|\| cif->flags == FFI_TYPE_LONGDOUBLE
557	n/a	#endif
558	n/a	)
559	n/a	rvalue = (void *) gpr[0];
560	n/a
561	n/a	/* Always skip the structure return address. */
562	n/a	argn = 1;
563	n/a
564	n/a	/* Grab the addresses of the arguments from the stack frame. */
565	n/a	for (i = 0; i < cif->nargs; i++)
566	n/a	{
567	n/a	if (arg_types[i]->type == FFI_TYPE_STRUCT
568	n/a	#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
569	n/a	\|\| arg_types[i]->type == FFI_TYPE_LONGDOUBLE
570	n/a	#endif
571	n/a	)
572	n/a	{
573	n/a	/* Straight copy of invisible reference. */
574	n/a	avalue[i] = (void *)gpr[argn++];
575	n/a	}
576	n/a	else if ((arg_types[i]->type == FFI_TYPE_DOUBLE
577	n/a	\|\| arg_types[i]->type == FFI_TYPE_SINT64
578	n/a	\|\| arg_types[i]->type == FFI_TYPE_UINT64)
579	n/a	/* gpr is 8-byte aligned. */
580	n/a	&& (argn % 2) != 0)
581	n/a	{
582	n/a	/* Align on a 8-byte boundary. */
583	n/a	scratch[0] = gpr[argn];
584	n/a	scratch[1] = gpr[argn+1];
585	n/a	avalue[i] = scratch;
586	n/a	scratch -= 2;
587	n/a	argn += 2;
588	n/a	}
589	n/a	else
590	n/a	{
591	n/a	/* Always right-justify. */
592	n/a	argn += ALIGN(arg_types[i]->size, FFI_SIZEOF_ARG) / FFI_SIZEOF_ARG;
593	n/a	avalue[i] = ((char *) &gpr[argn]) - arg_types[i]->size;
594	n/a	}
595	n/a	}
596	n/a
597	n/a	/* Invoke the closure. */
598	n/a	(closure->fun) (cif, rvalue, avalue, closure->user_data);
599	n/a
600	n/a	/* Tell ffi_closure_sparc how to perform return type promotions. */
601	n/a	return cif->rtype->type;
602	n/a	}
603	n/a
604	n/a	int
605	n/a	ffi_closure_sparc_inner_v9(ffi_closure *closure,
606	n/a	void rvalue, unsigned long gpr, double *fpr)
607	n/a	{
608	n/a	ffi_cif *cif;
609	n/a	ffi_type **arg_types;
610	n/a	void **avalue;
611	n/a	int i, argn, fp_slot_max;
612	n/a
613	n/a	cif = closure->cif;
614	n/a	arg_types = cif->arg_types;
615	n/a	avalue = alloca(cif->nargs * sizeof(void *));
616	n/a
617	n/a	/* Copy the caller's structure return address so that the closure
618	n/a	returns the data directly to the caller. */
619	n/a	if (cif->flags == FFI_TYPE_VOID
620	n/a	&& cif->rtype->type == FFI_TYPE_STRUCT)
621	n/a	{
622	n/a	rvalue = (void *) gpr[0];
623	n/a	/* Skip the structure return address. */
624	n/a	argn = 1;
625	n/a	}
626	n/a	else
627	n/a	argn = 0;
628	n/a
629	n/a	fp_slot_max = 16 - argn;
630	n/a
631	n/a	/* Grab the addresses of the arguments from the stack frame. */
632	n/a	for (i = 0; i < cif->nargs; i++)
633	n/a	{
634	n/a	if (arg_types[i]->type == FFI_TYPE_STRUCT)
635	n/a	{
636	n/a	if (arg_types[i]->size > 16)
637	n/a	{
638	n/a	/* Straight copy of invisible reference. */
639	n/a	avalue[i] = (void *)gpr[argn++];
640	n/a	}
641	n/a	else
642	n/a	{
643	n/a	/* Left-justify. */
644	n/a	ffi_v9_layout_struct(arg_types[i],
645	n/a	0,
646	n/a	(char *) &gpr[argn],
647	n/a	(char *) &gpr[argn],
648	n/a	(char *) &fpr[argn]);
649	n/a	avalue[i] = &gpr[argn];
650	n/a	argn += ALIGN(arg_types[i]->size, FFI_SIZEOF_ARG) / FFI_SIZEOF_ARG;
651	n/a	}
652	n/a	}
653	n/a	else
654	n/a	{
655	n/a	/* Right-justify. */
656	n/a	argn += ALIGN(arg_types[i]->size, FFI_SIZEOF_ARG) / FFI_SIZEOF_ARG;
657	n/a
658	n/a	/* Align on a 16-byte boundary. */
659	n/a	#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
660	n/a	if (arg_types[i]->type == FFI_TYPE_LONGDOUBLE && (argn % 2) != 0)
661	n/a	argn++;
662	n/a	#endif
663	n/a	if (i < fp_slot_max
664	n/a	&& (arg_types[i]->type == FFI_TYPE_FLOAT
665	n/a	\|\| arg_types[i]->type == FFI_TYPE_DOUBLE
666	n/a	#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
667	n/a	\|\| arg_types[i]->type == FFI_TYPE_LONGDOUBLE
668	n/a	#endif
669	n/a	))
670	n/a	avalue[i] = ((char *) &fpr[argn]) - arg_types[i]->size;
671	n/a	else
672	n/a	avalue[i] = ((char *) &gpr[argn]) - arg_types[i]->size;
673	n/a	}
674	n/a	}
675	n/a
676	n/a	/* Invoke the closure. */
677	n/a	(closure->fun) (cif, rvalue, avalue, closure->user_data);
678	n/a
679	n/a	/* Tell ffi_closure_sparc how to perform return type promotions. */
680	n/a	return cif->rtype->type;
681	n/a	}