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

#	count	content
1	n/a	/* -----------------------------------------------------------------------
2	n/a	ffi.c - Copyright (c) 2000, 2007 Software AG
3	n/a	Copyright (c) 2008 Red Hat, Inc
4	n/a
5	n/a	S390 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, EXPRESS
19	n/a	OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20	n/a	MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
21	n/a	IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR
22	n/a	OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
23	n/a	ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
24	n/a	OTHER DEALINGS IN THE SOFTWARE.
25	n/a	----------------------------------------------------------------------- */
26	n/a	/====================================================================/
27	n/a	/* Includes */
28	n/a	/* -------- */
29	n/a	/====================================================================/
30	n/a
31	n/a	#include <ffi.h>
32	n/a	#include <ffi_common.h>
33	n/a
34	n/a	#include <stdlib.h>
35	n/a	#include <stdio.h>
36	n/a
37	n/a	/====================== End of Includes =============================/
38	n/a
39	n/a	/====================================================================/
40	n/a	/* Defines */
41	n/a	/* ------- */
42	n/a	/====================================================================/
43	n/a
44	n/a	/* Maximum number of GPRs available for argument passing. */
45	n/a	#define MAX_GPRARGS 5
46	n/a
47	n/a	/* Maximum number of FPRs available for argument passing. */
48	n/a	#ifdef __s390x__
49	n/a	#define MAX_FPRARGS 4
50	n/a	#else
51	n/a	#define MAX_FPRARGS 2
52	n/a	#endif
53	n/a
54	n/a	/* Round to multiple of 16. */
55	n/a	#define ROUND_SIZE(size) (((size) + 15) & ~15)
56	n/a
57	n/a	/* If these values change, sysv.S must be adapted! */
58	n/a	#define FFI390_RET_VOID 0
59	n/a	#define FFI390_RET_STRUCT 1
60	n/a	#define FFI390_RET_FLOAT 2
61	n/a	#define FFI390_RET_DOUBLE 3
62	n/a	#define FFI390_RET_INT32 4
63	n/a	#define FFI390_RET_INT64 5
64	n/a
65	n/a	/===================== End of Defines ===============================/
66	n/a
67	n/a	/====================================================================/
68	n/a	/* Prototypes */
69	n/a	/* ---------- */
70	n/a	/====================================================================/
71	n/a
72	n/a	static void ffi_prep_args (unsigned char , extended_cif );
73	n/a	void
74	n/a	#if __GNUC__ > 3 \|\| (__GNUC__ == 3 && __GNUC_MINOR__ > 2)
75	n/a	__attribute__ ((visibility ("hidden")))
76	n/a	#endif
77	n/a	ffi_closure_helper_SYSV (ffi_closure , unsigned long ,
78	n/a	unsigned long long , unsigned long );
79	n/a
80	n/a	/====================== End of Prototypes ===========================/
81	n/a
82	n/a	/====================================================================/
83	n/a	/* Externals */
84	n/a	/* --------- */
85	n/a	/====================================================================/
86	n/a
87	n/a	extern void ffi_call_SYSV(unsigned,
88	n/a	extended_cif *,
89	n/a	void ()(unsigned char , extended_cif *),
90	n/a	unsigned,
91	n/a	void *,
92	n/a	void (*fn)(void));
93	n/a
94	n/a	extern void ffi_closure_SYSV(void);
95	n/a
96	n/a	/====================== End of Externals ============================/
97	n/a
98	n/a	/====================================================================/
99	n/a	/* */
100	n/a	/* Name - ffi_check_struct_type. */
101	n/a	/* */
102	n/a	/* Function - Determine if a structure can be passed within a */
103	n/a	/* general purpose or floating point register. */
104	n/a	/* */
105	n/a	/====================================================================/
106	n/a
107	n/a	static int
108	n/a	ffi_check_struct_type (ffi_type *arg)
109	n/a	{
110	n/a	size_t size = arg->size;
111	n/a
112	n/a	/* If the struct has just one element, look at that element
113	n/a	to find out whether to consider the struct as floating point. */
114	n/a	while (arg->type == FFI_TYPE_STRUCT
115	n/a	&& arg->elements[0] && !arg->elements[1])
116	n/a	arg = arg->elements[0];
117	n/a
118	n/a	/* Structs of size 1, 2, 4, and 8 are passed in registers,
119	n/a	just like the corresponding int/float types. */
120	n/a	switch (size)
121	n/a	{
122	n/a	case 1:
123	n/a	return FFI_TYPE_UINT8;
124	n/a
125	n/a	case 2:
126	n/a	return FFI_TYPE_UINT16;
127	n/a
128	n/a	case 4:
129	n/a	if (arg->type == FFI_TYPE_FLOAT)
130	n/a	return FFI_TYPE_FLOAT;
131	n/a	else
132	n/a	return FFI_TYPE_UINT32;
133	n/a
134	n/a	case 8:
135	n/a	if (arg->type == FFI_TYPE_DOUBLE)
136	n/a	return FFI_TYPE_DOUBLE;
137	n/a	else
138	n/a	return FFI_TYPE_UINT64;
139	n/a
140	n/a	default:
141	n/a	break;
142	n/a	}
143	n/a
144	n/a	/* Other structs are passed via a pointer to the data. */
145	n/a	return FFI_TYPE_POINTER;
146	n/a	}
147	n/a
148	n/a	/======================== End of Routine ============================/
149	n/a
150	n/a	/====================================================================/
151	n/a	/* */
152	n/a	/* Name - ffi_prep_args. */
153	n/a	/* */
154	n/a	/* Function - Prepare parameters for call to function. */
155	n/a	/* */
156	n/a	/* ffi_prep_args is called by the assembly routine once stack space */
157	n/a	/* has been allocated for the function's arguments. */
158	n/a	/* */
159	n/a	/====================================================================/
160	n/a
161	n/a	static void
162	n/a	ffi_prep_args (unsigned char stack, extended_cif ecif)
163	n/a	{
164	n/a	/* The stack space will be filled with those areas:
165	n/a
166	n/a	FPR argument register save area (highest addresses)
167	n/a	GPR argument register save area
168	n/a	temporary struct copies
169	n/a	overflow argument area (lowest addresses)
170	n/a
171	n/a	We set up the following pointers:
172	n/a
173	n/a	p_fpr: bottom of the FPR area (growing upwards)
174	n/a	p_gpr: bottom of the GPR area (growing upwards)
175	n/a	p_ov: bottom of the overflow area (growing upwards)
176	n/a	p_struct: top of the struct copy area (growing downwards)
177	n/a
178	n/a	All areas are kept aligned to twice the word size. */
179	n/a
180	n/a	int gpr_off = ecif->cif->bytes;
181	n/a	int fpr_off = gpr_off + ROUND_SIZE (MAX_GPRARGS * sizeof (long));
182	n/a
183	n/a	unsigned long long p_fpr = (unsigned long long )(stack + fpr_off);
184	n/a	unsigned long p_gpr = (unsigned long )(stack + gpr_off);
185	n/a	unsigned char p_struct = (unsigned char )p_gpr;
186	n/a	unsigned long p_ov = (unsigned long )stack;
187	n/a
188	n/a	int n_fpr = 0;
189	n/a	int n_gpr = 0;
190	n/a	int n_ov = 0;
191	n/a
192	n/a	ffi_type **ptr;
193	n/a	void **p_argv = ecif->avalue;
194	n/a	int i;
195	n/a
196	n/a	/* If we returning a structure then we set the first parameter register
197	n/a	to the address of where we are returning this structure. */
198	n/a
199	n/a	if (ecif->cif->flags == FFI390_RET_STRUCT)
200	n/a	p_gpr[n_gpr++] = (unsigned long) ecif->rvalue;
201	n/a
202	n/a	/* Now for the arguments. */
203	n/a
204	n/a	for (ptr = ecif->cif->arg_types, i = ecif->cif->nargs;
205	n/a	i > 0;
206	n/a	i--, ptr++, p_argv++)
207	n/a	{
208	n/a	void arg = p_argv;
209	n/a	int type = (*ptr)->type;
210	n/a
211	n/a	#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
212	n/a	/* 16-byte long double is passed like a struct. */
213	n/a	if (type == FFI_TYPE_LONGDOUBLE)
214	n/a	type = FFI_TYPE_STRUCT;
215	n/a	#endif
216	n/a
217	n/a	/* Check how a structure type is passed. */
218	n/a	if (type == FFI_TYPE_STRUCT)
219	n/a	{
220	n/a	type = ffi_check_struct_type (*ptr);
221	n/a
222	n/a	/* If we pass the struct via pointer, copy the data. */
223	n/a	if (type == FFI_TYPE_POINTER)
224	n/a	{
225	n/a	p_struct -= ROUND_SIZE ((*ptr)->size);
226	n/a	memcpy (p_struct, (char )arg, (ptr)->size);
227	n/a	arg = &p_struct;
228	n/a	}
229	n/a	}
230	n/a
231	n/a	/* Now handle all primitive int/pointer/float data types. */
232	n/a	switch (type)
233	n/a	{
234	n/a	case FFI_TYPE_DOUBLE:
235	n/a	if (n_fpr < MAX_FPRARGS)
236	n/a	p_fpr[n_fpr++] = (unsigned long long ) arg;
237	n/a	else
238	n/a	#ifdef __s390x__
239	n/a	p_ov[n_ov++] = (unsigned long ) arg;
240	n/a	#else
241	n/a	p_ov[n_ov++] = ((unsigned long *) arg)[0],
242	n/a	p_ov[n_ov++] = ((unsigned long *) arg)[1];
243	n/a	#endif
244	n/a	break;
245	n/a
246	n/a	case FFI_TYPE_FLOAT:
247	n/a	if (n_fpr < MAX_FPRARGS)
248	n/a	p_fpr[n_fpr++] = (long long) (unsigned int ) arg << 32;
249	n/a	else
250	n/a	p_ov[n_ov++] = (unsigned int ) arg;
251	n/a	break;
252	n/a
253	n/a	case FFI_TYPE_POINTER:
254	n/a	if (n_gpr < MAX_GPRARGS)
255	n/a	p_gpr[n_gpr++] = (unsigned long)(unsigned char *) arg;
256	n/a	else
257	n/a	p_ov[n_ov++] = (unsigned long)(unsigned char *) arg;
258	n/a	break;
259	n/a
260	n/a	case FFI_TYPE_UINT64:
261	n/a	case FFI_TYPE_SINT64:
262	n/a	#ifdef __s390x__
263	n/a	if (n_gpr < MAX_GPRARGS)
264	n/a	p_gpr[n_gpr++] = (unsigned long ) arg;
265	n/a	else
266	n/a	p_ov[n_ov++] = (unsigned long ) arg;
267	n/a	#else
268	n/a	if (n_gpr == MAX_GPRARGS-1)
269	n/a	n_gpr = MAX_GPRARGS;
270	n/a	if (n_gpr < MAX_GPRARGS)
271	n/a	p_gpr[n_gpr++] = ((unsigned long *) arg)[0],
272	n/a	p_gpr[n_gpr++] = ((unsigned long *) arg)[1];
273	n/a	else
274	n/a	p_ov[n_ov++] = ((unsigned long *) arg)[0],
275	n/a	p_ov[n_ov++] = ((unsigned long *) arg)[1];
276	n/a	#endif
277	n/a	break;
278	n/a
279	n/a	case FFI_TYPE_UINT32:
280	n/a	if (n_gpr < MAX_GPRARGS)
281	n/a	p_gpr[n_gpr++] = (unsigned int ) arg;
282	n/a	else
283	n/a	p_ov[n_ov++] = (unsigned int ) arg;
284	n/a	break;
285	n/a
286	n/a	case FFI_TYPE_INT:
287	n/a	case FFI_TYPE_SINT32:
288	n/a	if (n_gpr < MAX_GPRARGS)
289	n/a	p_gpr[n_gpr++] = (signed int ) arg;
290	n/a	else
291	n/a	p_ov[n_ov++] = (signed int ) arg;
292	n/a	break;
293	n/a
294	n/a	case FFI_TYPE_UINT16:
295	n/a	if (n_gpr < MAX_GPRARGS)
296	n/a	p_gpr[n_gpr++] = (unsigned short ) arg;
297	n/a	else
298	n/a	p_ov[n_ov++] = (unsigned short ) arg;
299	n/a	break;
300	n/a
301	n/a	case FFI_TYPE_SINT16:
302	n/a	if (n_gpr < MAX_GPRARGS)
303	n/a	p_gpr[n_gpr++] = (signed short ) arg;
304	n/a	else
305	n/a	p_ov[n_ov++] = (signed short ) arg;
306	n/a	break;
307	n/a
308	n/a	case FFI_TYPE_UINT8:
309	n/a	if (n_gpr < MAX_GPRARGS)
310	n/a	p_gpr[n_gpr++] = (unsigned char ) arg;
311	n/a	else
312	n/a	p_ov[n_ov++] = (unsigned char ) arg;
313	n/a	break;
314	n/a
315	n/a	case FFI_TYPE_SINT8:
316	n/a	if (n_gpr < MAX_GPRARGS)
317	n/a	p_gpr[n_gpr++] = (signed char ) arg;
318	n/a	else
319	n/a	p_ov[n_ov++] = (signed char ) arg;
320	n/a	break;
321	n/a
322	n/a	default:
323	n/a	FFI_ASSERT (0);
324	n/a	break;
325	n/a	}
326	n/a	}
327	n/a	}
328	n/a
329	n/a	/======================== End of Routine ============================/
330	n/a
331	n/a	/====================================================================/
332	n/a	/* */
333	n/a	/* Name - ffi_prep_cif_machdep. */
334	n/a	/* */
335	n/a	/* Function - Perform machine dependent CIF processing. */
336	n/a	/* */
337	n/a	/====================================================================/
338	n/a
339	n/a	ffi_status
340	n/a	ffi_prep_cif_machdep(ffi_cif *cif)
341	n/a	{
342	n/a	size_t struct_size = 0;
343	n/a	int n_gpr = 0;
344	n/a	int n_fpr = 0;
345	n/a	int n_ov = 0;
346	n/a
347	n/a	ffi_type **ptr;
348	n/a	int i;
349	n/a
350	n/a	/* Determine return value handling. */
351	n/a
352	n/a	switch (cif->rtype->type)
353	n/a	{
354	n/a	/* Void is easy. */
355	n/a	case FFI_TYPE_VOID:
356	n/a	cif->flags = FFI390_RET_VOID;
357	n/a	break;
358	n/a
359	n/a	/* Structures are returned via a hidden pointer. */
360	n/a	case FFI_TYPE_STRUCT:
361	n/a	cif->flags = FFI390_RET_STRUCT;
362	n/a	n_gpr++; /* We need one GPR to pass the pointer. */
363	n/a	break;
364	n/a
365	n/a	/* Floating point values are returned in fpr 0. */
366	n/a	case FFI_TYPE_FLOAT:
367	n/a	cif->flags = FFI390_RET_FLOAT;
368	n/a	break;
369	n/a
370	n/a	case FFI_TYPE_DOUBLE:
371	n/a	cif->flags = FFI390_RET_DOUBLE;
372	n/a	break;
373	n/a
374	n/a	#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
375	n/a	case FFI_TYPE_LONGDOUBLE:
376	n/a	cif->flags = FFI390_RET_STRUCT;
377	n/a	n_gpr++;
378	n/a	break;
379	n/a	#endif
380	n/a	/* Integer values are returned in gpr 2 (and gpr 3
381	n/a	for 64-bit values on 31-bit machines). */
382	n/a	case FFI_TYPE_UINT64:
383	n/a	case FFI_TYPE_SINT64:
384	n/a	cif->flags = FFI390_RET_INT64;
385	n/a	break;
386	n/a
387	n/a	case FFI_TYPE_POINTER:
388	n/a	case FFI_TYPE_INT:
389	n/a	case FFI_TYPE_UINT32:
390	n/a	case FFI_TYPE_SINT32:
391	n/a	case FFI_TYPE_UINT16:
392	n/a	case FFI_TYPE_SINT16:
393	n/a	case FFI_TYPE_UINT8:
394	n/a	case FFI_TYPE_SINT8:
395	n/a	/* These are to be extended to word size. */
396	n/a	#ifdef __s390x__
397	n/a	cif->flags = FFI390_RET_INT64;
398	n/a	#else
399	n/a	cif->flags = FFI390_RET_INT32;
400	n/a	#endif
401	n/a	break;
402	n/a
403	n/a	default:
404	n/a	FFI_ASSERT (0);
405	n/a	break;
406	n/a	}
407	n/a
408	n/a	/* Now for the arguments. */
409	n/a
410	n/a	for (ptr = cif->arg_types, i = cif->nargs;
411	n/a	i > 0;
412	n/a	i--, ptr++)
413	n/a	{
414	n/a	int type = (*ptr)->type;
415	n/a
416	n/a	#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
417	n/a	/* 16-byte long double is passed like a struct. */
418	n/a	if (type == FFI_TYPE_LONGDOUBLE)
419	n/a	type = FFI_TYPE_STRUCT;
420	n/a	#endif
421	n/a
422	n/a	/* Check how a structure type is passed. */
423	n/a	if (type == FFI_TYPE_STRUCT)
424	n/a	{
425	n/a	type = ffi_check_struct_type (*ptr);
426	n/a
427	n/a	/* If we pass the struct via pointer, we must reserve space
428	n/a	to copy its data for proper call-by-value semantics. */
429	n/a	if (type == FFI_TYPE_POINTER)
430	n/a	struct_size += ROUND_SIZE ((*ptr)->size);
431	n/a	}
432	n/a
433	n/a	/* Now handle all primitive int/float data types. */
434	n/a	switch (type)
435	n/a	{
436	n/a	/* The first MAX_FPRARGS floating point arguments
437	n/a	go in FPRs, the rest overflow to the stack. */
438	n/a
439	n/a	case FFI_TYPE_DOUBLE:
440	n/a	if (n_fpr < MAX_FPRARGS)
441	n/a	n_fpr++;
442	n/a	else
443	n/a	n_ov += sizeof (double) / sizeof (long);
444	n/a	break;
445	n/a
446	n/a	case FFI_TYPE_FLOAT:
447	n/a	if (n_fpr < MAX_FPRARGS)
448	n/a	n_fpr++;
449	n/a	else
450	n/a	n_ov++;
451	n/a	break;
452	n/a
453	n/a	/* On 31-bit machines, 64-bit integers are passed in GPR pairs,
454	n/a	if one is still available, or else on the stack. If only one
455	n/a	register is free, skip the register (it won't be used for any
456	n/a	subsequent argument either). */
457	n/a
458	n/a	#ifndef __s390x__
459	n/a	case FFI_TYPE_UINT64:
460	n/a	case FFI_TYPE_SINT64:
461	n/a	if (n_gpr == MAX_GPRARGS-1)
462	n/a	n_gpr = MAX_GPRARGS;
463	n/a	if (n_gpr < MAX_GPRARGS)
464	n/a	n_gpr += 2;
465	n/a	else
466	n/a	n_ov += 2;
467	n/a	break;
468	n/a	#endif
469	n/a
470	n/a	/* Everything else is passed in GPRs (until MAX_GPRARGS
471	n/a	have been used) or overflows to the stack. */
472	n/a
473	n/a	default:
474	n/a	if (n_gpr < MAX_GPRARGS)
475	n/a	n_gpr++;
476	n/a	else
477	n/a	n_ov++;
478	n/a	break;
479	n/a	}
480	n/a	}
481	n/a
482	n/a	/* Total stack space as required for overflow arguments
483	n/a	and temporary structure copies. */
484	n/a
485	n/a	cif->bytes = ROUND_SIZE (n_ov * sizeof (long)) + struct_size;
486	n/a
487	n/a	return FFI_OK;
488	n/a	}
489	n/a
490	n/a	/======================== End of Routine ============================/
491	n/a
492	n/a	/====================================================================/
493	n/a	/* */
494	n/a	/* Name - ffi_call. */
495	n/a	/* */
496	n/a	/* Function - Call the FFI routine. */
497	n/a	/* */
498	n/a	/====================================================================/
499	n/a
500	n/a	void
501	n/a	ffi_call(ffi_cif *cif,
502	n/a	void (*fn)(void),
503	n/a	void *rvalue,
504	n/a	void **avalue)
505	n/a	{
506	n/a	int ret_type = cif->flags;
507	n/a	extended_cif ecif;
508	n/a
509	n/a	ecif.cif = cif;
510	n/a	ecif.avalue = avalue;
511	n/a	ecif.rvalue = rvalue;
512	n/a
513	n/a	/* If we don't have a return value, we need to fake one. */
514	n/a	if (rvalue == NULL)
515	n/a	{
516	n/a	if (ret_type == FFI390_RET_STRUCT)
517	n/a	ecif.rvalue = alloca (cif->rtype->size);
518	n/a	else
519	n/a	ret_type = FFI390_RET_VOID;
520	n/a	}
521	n/a
522	n/a	switch (cif->abi)
523	n/a	{
524	n/a	case FFI_SYSV:
525	n/a	ffi_call_SYSV (cif->bytes, &ecif, ffi_prep_args,
526	n/a	ret_type, ecif.rvalue, fn);
527	n/a	break;
528	n/a
529	n/a	default:
530	n/a	FFI_ASSERT (0);
531	n/a	break;
532	n/a	}
533	n/a	}
534	n/a
535	n/a	/======================== End of Routine ============================/
536	n/a
537	n/a	/====================================================================/
538	n/a	/* */
539	n/a	/* Name - ffi_closure_helper_SYSV. */
540	n/a	/* */
541	n/a	/* Function - Call a FFI closure target function. */
542	n/a	/* */
543	n/a	/====================================================================/
544	n/a
545	n/a	void
546	n/a	ffi_closure_helper_SYSV (ffi_closure *closure,
547	n/a	unsigned long *p_gpr,
548	n/a	unsigned long long *p_fpr,
549	n/a	unsigned long *p_ov)
550	n/a	{
551	n/a	unsigned long long ret_buffer;
552	n/a
553	n/a	void *rvalue = &ret_buffer;
554	n/a	void **avalue;
555	n/a	void **p_arg;
556	n/a
557	n/a	int n_gpr = 0;
558	n/a	int n_fpr = 0;
559	n/a	int n_ov = 0;
560	n/a
561	n/a	ffi_type **ptr;
562	n/a	int i;
563	n/a
564	n/a	/* Allocate buffer for argument list pointers. */
565	n/a
566	n/a	p_arg = avalue = alloca (closure->cif->nargs * sizeof (void *));
567	n/a
568	n/a	/* If we returning a structure, pass the structure address
569	n/a	directly to the target function. Otherwise, have the target
570	n/a	function store the return value to the GPR save area. */
571	n/a
572	n/a	if (closure->cif->flags == FFI390_RET_STRUCT)
573	n/a	rvalue = (void *) p_gpr[n_gpr++];
574	n/a
575	n/a	/* Now for the arguments. */
576	n/a
577	n/a	for (ptr = closure->cif->arg_types, i = closure->cif->nargs;
578	n/a	i > 0;
579	n/a	i--, p_arg++, ptr++)
580	n/a	{
581	n/a	int deref_struct_pointer = 0;
582	n/a	int type = (*ptr)->type;
583	n/a
584	n/a	#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
585	n/a	/* 16-byte long double is passed like a struct. */
586	n/a	if (type == FFI_TYPE_LONGDOUBLE)
587	n/a	type = FFI_TYPE_STRUCT;
588	n/a	#endif
589	n/a
590	n/a	/* Check how a structure type is passed. */
591	n/a	if (type == FFI_TYPE_STRUCT)
592	n/a	{
593	n/a	type = ffi_check_struct_type (*ptr);
594	n/a
595	n/a	/* If we pass the struct via pointer, remember to
596	n/a	retrieve the pointer later. */
597	n/a	if (type == FFI_TYPE_POINTER)
598	n/a	deref_struct_pointer = 1;
599	n/a	}
600	n/a
601	n/a	/* Pointers are passed like UINTs of the same size. */
602	n/a	if (type == FFI_TYPE_POINTER)
603	n/a	#ifdef __s390x__
604	n/a	type = FFI_TYPE_UINT64;
605	n/a	#else
606	n/a	type = FFI_TYPE_UINT32;
607	n/a	#endif
608	n/a
609	n/a	/* Now handle all primitive int/float data types. */
610	n/a	switch (type)
611	n/a	{
612	n/a	case FFI_TYPE_DOUBLE:
613	n/a	if (n_fpr < MAX_FPRARGS)
614	n/a	*p_arg = &p_fpr[n_fpr++];
615	n/a	else
616	n/a	*p_arg = &p_ov[n_ov],
617	n/a	n_ov += sizeof (double) / sizeof (long);
618	n/a	break;
619	n/a
620	n/a	case FFI_TYPE_FLOAT:
621	n/a	if (n_fpr < MAX_FPRARGS)
622	n/a	*p_arg = &p_fpr[n_fpr++];
623	n/a	else
624	n/a	p_arg = (char )&p_ov[n_ov++] + sizeof (long) - 4;
625	n/a	break;
626	n/a
627	n/a	case FFI_TYPE_UINT64:
628	n/a	case FFI_TYPE_SINT64:
629	n/a	#ifdef __s390x__
630	n/a	if (n_gpr < MAX_GPRARGS)
631	n/a	*p_arg = &p_gpr[n_gpr++];
632	n/a	else
633	n/a	*p_arg = &p_ov[n_ov++];
634	n/a	#else
635	n/a	if (n_gpr == MAX_GPRARGS-1)
636	n/a	n_gpr = MAX_GPRARGS;
637	n/a	if (n_gpr < MAX_GPRARGS)
638	n/a	*p_arg = &p_gpr[n_gpr], n_gpr += 2;
639	n/a	else
640	n/a	*p_arg = &p_ov[n_ov], n_ov += 2;
641	n/a	#endif
642	n/a	break;
643	n/a
644	n/a	case FFI_TYPE_INT:
645	n/a	case FFI_TYPE_UINT32:
646	n/a	case FFI_TYPE_SINT32:
647	n/a	if (n_gpr < MAX_GPRARGS)
648	n/a	p_arg = (char )&p_gpr[n_gpr++] + sizeof (long) - 4;
649	n/a	else
650	n/a	p_arg = (char )&p_ov[n_ov++] + sizeof (long) - 4;
651	n/a	break;
652	n/a
653	n/a	case FFI_TYPE_UINT16:
654	n/a	case FFI_TYPE_SINT16:
655	n/a	if (n_gpr < MAX_GPRARGS)
656	n/a	p_arg = (char )&p_gpr[n_gpr++] + sizeof (long) - 2;
657	n/a	else
658	n/a	p_arg = (char )&p_ov[n_ov++] + sizeof (long) - 2;
659	n/a	break;
660	n/a
661	n/a	case FFI_TYPE_UINT8:
662	n/a	case FFI_TYPE_SINT8:
663	n/a	if (n_gpr < MAX_GPRARGS)
664	n/a	p_arg = (char )&p_gpr[n_gpr++] + sizeof (long) - 1;
665	n/a	else
666	n/a	p_arg = (char )&p_ov[n_ov++] + sizeof (long) - 1;
667	n/a	break;
668	n/a
669	n/a	default:
670	n/a	FFI_ASSERT (0);
671	n/a	break;
672	n/a	}
673	n/a
674	n/a	/* If this is a struct passed via pointer, we need to
675	n/a	actually retrieve that pointer. */
676	n/a	if (deref_struct_pointer)
677	n/a	p_arg = (void *)p_arg;
678	n/a	}
679	n/a
680	n/a
681	n/a	/* Call the target function. */
682	n/a	(closure->fun) (closure->cif, rvalue, avalue, closure->user_data);
683	n/a
684	n/a	/* Convert the return value. */
685	n/a	switch (closure->cif->rtype->type)
686	n/a	{
687	n/a	/* Void is easy, and so is struct. */
688	n/a	case FFI_TYPE_VOID:
689	n/a	case FFI_TYPE_STRUCT:
690	n/a	#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
691	n/a	case FFI_TYPE_LONGDOUBLE:
692	n/a	#endif
693	n/a	break;
694	n/a
695	n/a	/* Floating point values are returned in fpr 0. */
696	n/a	case FFI_TYPE_FLOAT:
697	n/a	p_fpr[0] = (long long) (unsigned int ) rvalue << 32;
698	n/a	break;
699	n/a
700	n/a	case FFI_TYPE_DOUBLE:
701	n/a	p_fpr[0] = (unsigned long long ) rvalue;
702	n/a	break;
703	n/a
704	n/a	/* Integer values are returned in gpr 2 (and gpr 3
705	n/a	for 64-bit values on 31-bit machines). */
706	n/a	case FFI_TYPE_UINT64:
707	n/a	case FFI_TYPE_SINT64:
708	n/a	#ifdef __s390x__
709	n/a	p_gpr[0] = (unsigned long ) rvalue;
710	n/a	#else
711	n/a	p_gpr[0] = ((unsigned long *) rvalue)[0],
712	n/a	p_gpr[1] = ((unsigned long *) rvalue)[1];
713	n/a	#endif
714	n/a	break;
715	n/a
716	n/a	case FFI_TYPE_POINTER:
717	n/a	case FFI_TYPE_UINT32:
718	n/a	case FFI_TYPE_UINT16:
719	n/a	case FFI_TYPE_UINT8:
720	n/a	p_gpr[0] = (unsigned long ) rvalue;
721	n/a	break;
722	n/a
723	n/a	case FFI_TYPE_INT:
724	n/a	case FFI_TYPE_SINT32:
725	n/a	case FFI_TYPE_SINT16:
726	n/a	case FFI_TYPE_SINT8:
727	n/a	p_gpr[0] = (signed long ) rvalue;
728	n/a	break;
729	n/a
730	n/a	default:
731	n/a	FFI_ASSERT (0);
732	n/a	break;
733	n/a	}
734	n/a	}
735	n/a
736	n/a	/======================== End of Routine ============================/
737	n/a
738	n/a	/====================================================================/
739	n/a	/* */
740	n/a	/* Name - ffi_prep_closure_loc. */
741	n/a	/* */
742	n/a	/* Function - Prepare a FFI closure. */
743	n/a	/* */
744	n/a	/====================================================================/
745	n/a
746	n/a	ffi_status
747	n/a	ffi_prep_closure_loc (ffi_closure *closure,
748	n/a	ffi_cif *cif,
749	n/a	void (fun) (ffi_cif , void , void , void ),
750	n/a	void *user_data,
751	n/a	void *codeloc)
752	n/a	{
753	n/a	if (cif->abi != FFI_SYSV)
754	n/a	return FFI_BAD_ABI;
755	n/a
756	n/a	#ifndef __s390x__
757	n/a	(short )&closure->tramp [0] = 0x0d10; /* basr %r1,0 */
758	n/a	(short )&closure->tramp [2] = 0x9801; /* lm %r0,%r1,6(%r1) */
759	n/a	(short )&closure->tramp [4] = 0x1006;
760	n/a	(short )&closure->tramp [6] = 0x07f1; /* br %r1 */
761	n/a	(long )&closure->tramp [8] = (long)codeloc;
762	n/a	(long )&closure->tramp[12] = (long)&ffi_closure_SYSV;
763	n/a	#else
764	n/a	(short )&closure->tramp [0] = 0x0d10; /* basr %r1,0 */
765	n/a	(short )&closure->tramp [2] = 0xeb01; /* lmg %r0,%r1,14(%r1) */
766	n/a	(short )&closure->tramp [4] = 0x100e;
767	n/a	(short )&closure->tramp [6] = 0x0004;
768	n/a	(short )&closure->tramp [8] = 0x07f1; /* br %r1 */
769	n/a	(long )&closure->tramp[16] = (long)codeloc;
770	n/a	(long )&closure->tramp[24] = (long)&ffi_closure_SYSV;
771	n/a	#endif
772	n/a
773	n/a	closure->cif = cif;
774	n/a	closure->user_data = user_data;
775	n/a	closure->fun = fun;
776	n/a
777	n/a	return FFI_OK;
778	n/a	}
779	n/a
780	n/a	/======================== End of Routine ============================/
781	n/a