Python code coverage for Modules/_ctypes/libffi/src/powerpc/ffi_linux64.c

#	count	content
1	n/a	/* -----------------------------------------------------------------------
2	n/a	ffi_linux64.c - Copyright (C) 2013 IBM
3	n/a	Copyright (C) 2011 Anthony Green
4	n/a	Copyright (C) 2011 Kyle Moffett
5	n/a	Copyright (C) 2008 Red Hat, Inc
6	n/a	Copyright (C) 2007, 2008 Free Software Foundation, Inc
7	n/a	Copyright (c) 1998 Geoffrey Keating
8	n/a
9	n/a	PowerPC Foreign Function Interface
10	n/a
11	n/a	Permission is hereby granted, free of charge, to any person obtaining
12	n/a	a copy of this software and associated documentation files (the
13	n/a	``Software''), to deal in the Software without restriction, including
14	n/a	without limitation the rights to use, copy, modify, merge, publish,
15	n/a	distribute, sublicense, and/or sell copies of the Software, and to
16	n/a	permit persons to whom the Software is furnished to do so, subject to
17	n/a	the following conditions:
18	n/a
19	n/a	The above copyright notice and this permission notice shall be included
20	n/a	in all copies or substantial portions of the Software.
21	n/a
22	n/a	THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, EXPRESS
23	n/a	OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
24	n/a	MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
25	n/a	IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR
26	n/a	OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
27	n/a	ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
28	n/a	OTHER DEALINGS IN THE SOFTWARE.
29	n/a	----------------------------------------------------------------------- */
30	n/a
31	n/a	#include "ffi.h"
32	n/a
33	n/a	#ifdef POWERPC64
34	n/a	#include "ffi_common.h"
35	n/a	#include "ffi_powerpc.h"
36	n/a
37	n/a
38	n/a	/* About the LINUX64 ABI. */
39	n/a	enum {
40	n/a	NUM_GPR_ARG_REGISTERS64 = 8,
41	n/a	NUM_FPR_ARG_REGISTERS64 = 13
42	n/a	};
43	n/a	enum { ASM_NEEDS_REGISTERS64 = 4 };
44	n/a
45	n/a
46	n/a	#if HAVE_LONG_DOUBLE_VARIANT && FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
47	n/a	/* Adjust size of ffi_type_longdouble. */
48	n/a	void FFI_HIDDEN
49	n/a	ffi_prep_types_linux64 (ffi_abi abi)
50	n/a	{
51	n/a	if ((abi & (FFI_LINUX \| FFI_LINUX_LONG_DOUBLE_128)) == FFI_LINUX)
52	n/a	{
53	n/a	ffi_type_longdouble.size = 8;
54	n/a	ffi_type_longdouble.alignment = 8;
55	n/a	}
56	n/a	else
57	n/a	{
58	n/a	ffi_type_longdouble.size = 16;
59	n/a	ffi_type_longdouble.alignment = 16;
60	n/a	}
61	n/a	}
62	n/a	#endif
63	n/a
64	n/a
65	n/a	#if _CALL_ELF == 2
66	n/a	static unsigned int
67	n/a	discover_homogeneous_aggregate (const ffi_type t, unsigned int elnum)
68	n/a	{
69	n/a	switch (t->type)
70	n/a	{
71	n/a	case FFI_TYPE_FLOAT:
72	n/a	case FFI_TYPE_DOUBLE:
73	n/a	*elnum = 1;
74	n/a	return (int) t->type;
75	n/a
76	n/a	case FFI_TYPE_STRUCT:;
77	n/a	{
78	n/a	unsigned int base_elt = 0, total_elnum = 0;
79	n/a	ffi_type **el = t->elements;
80	n/a	while (*el)
81	n/a	{
82	n/a	unsigned int el_elt, el_elnum = 0;
83	n/a	el_elt = discover_homogeneous_aggregate (*el, &el_elnum);
84	n/a	if (el_elt == 0
85	n/a	\|\| (base_elt && base_elt != el_elt))
86	n/a	return 0;
87	n/a	base_elt = el_elt;
88	n/a	total_elnum += el_elnum;
89	n/a	if (total_elnum > 8)
90	n/a	return 0;
91	n/a	el++;
92	n/a	}
93	n/a	*elnum = total_elnum;
94	n/a	return base_elt;
95	n/a	}
96	n/a
97	n/a	default:
98	n/a	return 0;
99	n/a	}
100	n/a	}
101	n/a	#endif
102	n/a
103	n/a
104	n/a	/* Perform machine dependent cif processing */
105	n/a	static ffi_status
106	n/a	ffi_prep_cif_linux64_core (ffi_cif *cif)
107	n/a	{
108	n/a	ffi_type **ptr;
109	n/a	unsigned bytes;
110	n/a	unsigned i, fparg_count = 0, intarg_count = 0;
111	n/a	unsigned flags = cif->flags;
112	n/a	#if _CALL_ELF == 2
113	n/a	unsigned int elt, elnum;
114	n/a	#endif
115	n/a
116	n/a	#if FFI_TYPE_LONGDOUBLE == FFI_TYPE_DOUBLE
117	n/a	/* If compiled without long double support.. */
118	n/a	if ((cif->abi & FFI_LINUX_LONG_DOUBLE_128) != 0)
119	n/a	return FFI_BAD_ABI;
120	n/a	#endif
121	n/a
122	n/a	/* The machine-independent calculation of cif->bytes doesn't work
123	n/a	for us. Redo the calculation. */
124	n/a	#if _CALL_ELF == 2
125	n/a	/* Space for backchain, CR, LR, TOC and the asm's temp regs. */
126	n/a	bytes = (4 + ASM_NEEDS_REGISTERS64) * sizeof (long);
127	n/a
128	n/a	/* Space for the general registers. */
129	n/a	bytes += NUM_GPR_ARG_REGISTERS64 * sizeof (long);
130	n/a	#else
131	n/a	/* Space for backchain, CR, LR, cc/ld doubleword, TOC and the asm's temp
132	n/a	regs. */
133	n/a	bytes = (6 + ASM_NEEDS_REGISTERS64) * sizeof (long);
134	n/a
135	n/a	/* Space for the mandatory parm save area and general registers. */
136	n/a	bytes += 2 * NUM_GPR_ARG_REGISTERS64 * sizeof (long);
137	n/a	#endif
138	n/a
139	n/a	/* Return value handling. */
140	n/a	switch (cif->rtype->type)
141	n/a	{
142	n/a	#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
143	n/a	case FFI_TYPE_LONGDOUBLE:
144	n/a	if ((cif->abi & FFI_LINUX_LONG_DOUBLE_128) != 0)
145	n/a	flags \|= FLAG_RETURNS_128BITS;
146	n/a	/* Fall through. */
147	n/a	#endif
148	n/a	case FFI_TYPE_DOUBLE:
149	n/a	flags \|= FLAG_RETURNS_64BITS;
150	n/a	/* Fall through. */
151	n/a	case FFI_TYPE_FLOAT:
152	n/a	flags \|= FLAG_RETURNS_FP;
153	n/a	break;
154	n/a
155	n/a	case FFI_TYPE_UINT128:
156	n/a	flags \|= FLAG_RETURNS_128BITS;
157	n/a	/* Fall through. */
158	n/a	case FFI_TYPE_UINT64:
159	n/a	case FFI_TYPE_SINT64:
160	n/a	flags \|= FLAG_RETURNS_64BITS;
161	n/a	break;
162	n/a
163	n/a	case FFI_TYPE_STRUCT:
164	n/a	#if _CALL_ELF == 2
165	n/a	elt = discover_homogeneous_aggregate (cif->rtype, &elnum);
166	n/a	if (elt)
167	n/a	{
168	n/a	if (elt == FFI_TYPE_DOUBLE)
169	n/a	flags \|= FLAG_RETURNS_64BITS;
170	n/a	flags \|= FLAG_RETURNS_FP \| FLAG_RETURNS_SMST;
171	n/a	break;
172	n/a	}
173	n/a	if (cif->rtype->size <= 16)
174	n/a	{
175	n/a	flags \|= FLAG_RETURNS_SMST;
176	n/a	break;
177	n/a	}
178	n/a	#endif
179	n/a	intarg_count++;
180	n/a	flags \|= FLAG_RETVAL_REFERENCE;
181	n/a	/* Fall through. */
182	n/a	case FFI_TYPE_VOID:
183	n/a	flags \|= FLAG_RETURNS_NOTHING;
184	n/a	break;
185	n/a
186	n/a	default:
187	n/a	/* Returns 32-bit integer, or similar. Nothing to do here. */
188	n/a	break;
189	n/a	}
190	n/a
191	n/a	for (ptr = cif->arg_types, i = cif->nargs; i > 0; i--, ptr++)
192	n/a	{
193	n/a	unsigned int align;
194	n/a
195	n/a	switch ((*ptr)->type)
196	n/a	{
197	n/a	#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
198	n/a	case FFI_TYPE_LONGDOUBLE:
199	n/a	if ((cif->abi & FFI_LINUX_LONG_DOUBLE_128) != 0)
200	n/a	{
201	n/a	fparg_count++;
202	n/a	intarg_count++;
203	n/a	}
204	n/a	/* Fall through. */
205	n/a	#endif
206	n/a	case FFI_TYPE_DOUBLE:
207	n/a	case FFI_TYPE_FLOAT:
208	n/a	fparg_count++;
209	n/a	intarg_count++;
210	n/a	if (fparg_count > NUM_FPR_ARG_REGISTERS64)
211	n/a	flags \|= FLAG_ARG_NEEDS_PSAVE;
212	n/a	break;
213	n/a
214	n/a	case FFI_TYPE_STRUCT:
215	n/a	if ((cif->abi & FFI_LINUX_STRUCT_ALIGN) != 0)
216	n/a	{
217	n/a	align = (*ptr)->alignment;
218	n/a	if (align > 16)
219	n/a	align = 16;
220	n/a	align = align / 8;
221	n/a	if (align > 1)
222	n/a	intarg_count = ALIGN (intarg_count, align);
223	n/a	}
224	n/a	intarg_count += ((*ptr)->size + 7) / 8;
225	n/a	#if _CALL_ELF == 2
226	n/a	elt = discover_homogeneous_aggregate (*ptr, &elnum);
227	n/a	if (elt)
228	n/a	{
229	n/a	fparg_count += elnum;
230	n/a	if (fparg_count > NUM_FPR_ARG_REGISTERS64)
231	n/a	flags \|= FLAG_ARG_NEEDS_PSAVE;
232	n/a	}
233	n/a	else
234	n/a	#endif
235	n/a	{
236	n/a	if (intarg_count > NUM_GPR_ARG_REGISTERS64)
237	n/a	flags \|= FLAG_ARG_NEEDS_PSAVE;
238	n/a	}
239	n/a	break;
240	n/a
241	n/a	case FFI_TYPE_POINTER:
242	n/a	case FFI_TYPE_UINT64:
243	n/a	case FFI_TYPE_SINT64:
244	n/a	case FFI_TYPE_INT:
245	n/a	case FFI_TYPE_UINT32:
246	n/a	case FFI_TYPE_SINT32:
247	n/a	case FFI_TYPE_UINT16:
248	n/a	case FFI_TYPE_SINT16:
249	n/a	case FFI_TYPE_UINT8:
250	n/a	case FFI_TYPE_SINT8:
251	n/a	/* Everything else is passed as a 8-byte word in a GPR, either
252	n/a	the object itself or a pointer to it. */
253	n/a	intarg_count++;
254	n/a	if (intarg_count > NUM_GPR_ARG_REGISTERS64)
255	n/a	flags \|= FLAG_ARG_NEEDS_PSAVE;
256	n/a	break;
257	n/a	default:
258	n/a	FFI_ASSERT (0);
259	n/a	}
260	n/a	}
261	n/a
262	n/a	if (fparg_count != 0)
263	n/a	flags \|= FLAG_FP_ARGUMENTS;
264	n/a	if (intarg_count > 4)
265	n/a	flags \|= FLAG_4_GPR_ARGUMENTS;
266	n/a
267	n/a	/* Space for the FPR registers, if needed. */
268	n/a	if (fparg_count != 0)
269	n/a	bytes += NUM_FPR_ARG_REGISTERS64 * sizeof (double);
270	n/a
271	n/a	/* Stack space. */
272	n/a	#if _CALL_ELF == 2
273	n/a	if ((flags & FLAG_ARG_NEEDS_PSAVE) != 0)
274	n/a	bytes += intarg_count * sizeof (long);
275	n/a	#else
276	n/a	if (intarg_count > NUM_GPR_ARG_REGISTERS64)
277	n/a	bytes += (intarg_count - NUM_GPR_ARG_REGISTERS64) * sizeof (long);
278	n/a	#endif
279	n/a
280	n/a	/* The stack space allocated needs to be a multiple of 16 bytes. */
281	n/a	bytes = (bytes + 15) & ~0xF;
282	n/a
283	n/a	cif->flags = flags;
284	n/a	cif->bytes = bytes;
285	n/a
286	n/a	return FFI_OK;
287	n/a	}
288	n/a
289	n/a	ffi_status FFI_HIDDEN
290	n/a	ffi_prep_cif_linux64 (ffi_cif *cif)
291	n/a	{
292	n/a	if ((cif->abi & FFI_LINUX) != 0)
293	n/a	cif->nfixedargs = cif->nargs;
294	n/a	#if _CALL_ELF != 2
295	n/a	else if (cif->abi == FFI_COMPAT_LINUX64)
296	n/a	{
297	n/a	/* This call is from old code. Don't touch cif->nfixedargs
298	n/a	since old code will be using a smaller cif. */
299	n/a	cif->flags \|= FLAG_COMPAT;
300	n/a	/* Translate to new abi value. */
301	n/a	cif->abi = FFI_LINUX \| FFI_LINUX_LONG_DOUBLE_128;
302	n/a	}
303	n/a	#endif
304	n/a	else
305	n/a	return FFI_BAD_ABI;
306	n/a	return ffi_prep_cif_linux64_core (cif);
307	n/a	}
308	n/a
309	n/a	ffi_status FFI_HIDDEN
310	n/a	ffi_prep_cif_linux64_var (ffi_cif *cif,
311	n/a	unsigned int nfixedargs,
312	n/a	unsigned int ntotalargs MAYBE_UNUSED)
313	n/a	{
314	n/a	if ((cif->abi & FFI_LINUX) != 0)
315	n/a	cif->nfixedargs = nfixedargs;
316	n/a	#if _CALL_ELF != 2
317	n/a	else if (cif->abi == FFI_COMPAT_LINUX64)
318	n/a	{
319	n/a	/* This call is from old code. Don't touch cif->nfixedargs
320	n/a	since old code will be using a smaller cif. */
321	n/a	cif->flags \|= FLAG_COMPAT;
322	n/a	/* Translate to new abi value. */
323	n/a	cif->abi = FFI_LINUX \| FFI_LINUX_LONG_DOUBLE_128;
324	n/a	}
325	n/a	#endif
326	n/a	else
327	n/a	return FFI_BAD_ABI;
328	n/a	#if _CALL_ELF == 2
329	n/a	cif->flags \|= FLAG_ARG_NEEDS_PSAVE;
330	n/a	#endif
331	n/a	return ffi_prep_cif_linux64_core (cif);
332	n/a	}
333	n/a
334	n/a
335	n/a	/* ffi_prep_args64 is called by the assembly routine once stack space
336	n/a	has been allocated for the function's arguments.
337	n/a
338	n/a	The stack layout we want looks like this:
339	n/a
340	n/a	\| Ret addr from ffi_call_LINUX64 8bytes \| higher addresses
341	n/a	\|--------------------------------------------\|
342	n/a	\| CR save area 8bytes \|
343	n/a	\|--------------------------------------------\|
344	n/a	\| Previous backchain pointer 8 \| stack pointer here
345	n/a	\|--------------------------------------------\|<+ <<< on entry to
346	n/a	\| Saved r28-r31 4*8 \| \| ffi_call_LINUX64
347	n/a	\|--------------------------------------------\| \|
348	n/a	\| GPR registers r3-r10 8*8 \| \|
349	n/a	\|--------------------------------------------\| \|
350	n/a	\| FPR registers f1-f13 (optional) 13*8 \| \|
351	n/a	\|--------------------------------------------\| \|
352	n/a	\| Parameter save area \| \|
353	n/a	\|--------------------------------------------\| \|
354	n/a	\| TOC save area 8 \| \|
355	n/a	\|--------------------------------------------\| \| stack \|
356	n/a	\| Linker doubleword 8 \| \| grows \|
357	n/a	\|--------------------------------------------\| \| down V
358	n/a	\| Compiler doubleword 8 \| \|
359	n/a	\|--------------------------------------------\| \| lower addresses
360	n/a	\| Space for callee's LR 8 \| \|
361	n/a	\|--------------------------------------------\| \|
362	n/a	\| CR save area 8 \| \|
363	n/a	\|--------------------------------------------\| \| stack pointer here
364	n/a	\| Current backchain pointer 8 \|-/ during
365	n/a	\|--------------------------------------------\| <<< ffi_call_LINUX64
366	n/a
367	n/a	*/
368	n/a
369	n/a	void FFI_HIDDEN
370	n/a	ffi_prep_args64 (extended_cif ecif, unsigned long const stack)
371	n/a	{
372	n/a	const unsigned long bytes = ecif->cif->bytes;
373	n/a	const unsigned long flags = ecif->cif->flags;
374	n/a
375	n/a	typedef union
376	n/a	{
377	n/a	char *c;
378	n/a	unsigned long *ul;
379	n/a	float *f;
380	n/a	double *d;
381	n/a	size_t p;
382	n/a	} valp;
383	n/a
384	n/a	/* 'stacktop' points at the previous backchain pointer. */
385	n/a	valp stacktop;
386	n/a
387	n/a	/* 'next_arg' points at the space for gpr3, and grows upwards as
388	n/a	we use GPR registers, then continues at rest. */
389	n/a	valp gpr_base;
390	n/a	valp gpr_end;
391	n/a	valp rest;
392	n/a	valp next_arg;
393	n/a
394	n/a	/* 'fpr_base' points at the space for fpr3, and grows upwards as
395	n/a	we use FPR registers. */
396	n/a	valp fpr_base;
397	n/a	unsigned int fparg_count;
398	n/a
399	n/a	unsigned int i, words, nargs, nfixedargs;
400	n/a	ffi_type **ptr;
401	n/a	double double_tmp;
402	n/a	union
403	n/a	{
404	n/a	void **v;
405	n/a	char **c;
406	n/a	signed char **sc;
407	n/a	unsigned char **uc;
408	n/a	signed short **ss;
409	n/a	unsigned short **us;
410	n/a	signed int **si;
411	n/a	unsigned int **ui;
412	n/a	unsigned long **ul;
413	n/a	float **f;
414	n/a	double **d;
415	n/a	} p_argv;
416	n/a	unsigned long gprvalue;
417	n/a	unsigned long align;
418	n/a
419	n/a	stacktop.c = (char *) stack + bytes;
420	n/a	gpr_base.ul = stacktop.ul - ASM_NEEDS_REGISTERS64 - NUM_GPR_ARG_REGISTERS64;
421	n/a	gpr_end.ul = gpr_base.ul + NUM_GPR_ARG_REGISTERS64;
422	n/a	#if _CALL_ELF == 2
423	n/a	rest.ul = stack + 4 + NUM_GPR_ARG_REGISTERS64;
424	n/a	#else
425	n/a	rest.ul = stack + 6 + NUM_GPR_ARG_REGISTERS64;
426	n/a	#endif
427	n/a	fpr_base.d = gpr_base.d - NUM_FPR_ARG_REGISTERS64;
428	n/a	fparg_count = 0;
429	n/a	next_arg.ul = gpr_base.ul;
430	n/a
431	n/a	/* Check that everything starts aligned properly. */
432	n/a	FFI_ASSERT (((unsigned long) (char *) stack & 0xF) == 0);
433	n/a	FFI_ASSERT (((unsigned long) stacktop.c & 0xF) == 0);
434	n/a	FFI_ASSERT ((bytes & 0xF) == 0);
435	n/a
436	n/a	/* Deal with return values that are actually pass-by-reference. */
437	n/a	if (flags & FLAG_RETVAL_REFERENCE)
438	n/a	next_arg.ul++ = (unsigned long) (char ) ecif->rvalue;
439	n/a
440	n/a	/* Now for the arguments. */
441	n/a	p_argv.v = ecif->avalue;
442	n/a	nargs = ecif->cif->nargs;
443	n/a	#if _CALL_ELF != 2
444	n/a	nfixedargs = (unsigned) -1;
445	n/a	if ((flags & FLAG_COMPAT) == 0)
446	n/a	#endif
447	n/a	nfixedargs = ecif->cif->nfixedargs;
448	n/a	for (ptr = ecif->cif->arg_types, i = 0;
449	n/a	i < nargs;
450	n/a	i++, ptr++, p_argv.v++)
451	n/a	{
452	n/a	#if _CALL_ELF == 2
453	n/a	unsigned int elt, elnum;
454	n/a	#endif
455	n/a
456	n/a	switch ((*ptr)->type)
457	n/a	{
458	n/a	#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
459	n/a	case FFI_TYPE_LONGDOUBLE:
460	n/a	if ((ecif->cif->abi & FFI_LINUX_LONG_DOUBLE_128) != 0)
461	n/a	{
462	n/a	double_tmp = (*p_argv.d)[0];
463	n/a	if (fparg_count < NUM_FPR_ARG_REGISTERS64 && i < nfixedargs)
464	n/a	{
465	n/a	*fpr_base.d++ = double_tmp;
466	n/a	# if _CALL_ELF != 2
467	n/a	if ((flags & FLAG_COMPAT) != 0)
468	n/a	*next_arg.d = double_tmp;
469	n/a	# endif
470	n/a	}
471	n/a	else
472	n/a	*next_arg.d = double_tmp;
473	n/a	if (++next_arg.ul == gpr_end.ul)
474	n/a	next_arg.ul = rest.ul;
475	n/a	fparg_count++;
476	n/a	double_tmp = (*p_argv.d)[1];
477	n/a	if (fparg_count < NUM_FPR_ARG_REGISTERS64 && i < nfixedargs)
478	n/a	{
479	n/a	*fpr_base.d++ = double_tmp;
480	n/a	# if _CALL_ELF != 2
481	n/a	if ((flags & FLAG_COMPAT) != 0)
482	n/a	*next_arg.d = double_tmp;
483	n/a	# endif
484	n/a	}
485	n/a	else
486	n/a	*next_arg.d = double_tmp;
487	n/a	if (++next_arg.ul == gpr_end.ul)
488	n/a	next_arg.ul = rest.ul;
489	n/a	fparg_count++;
490	n/a	FFI_ASSERT (__LDBL_MANT_DIG__ == 106);
491	n/a	FFI_ASSERT (flags & FLAG_FP_ARGUMENTS);
492	n/a	break;
493	n/a	}
494	n/a	/* Fall through. */
495	n/a	#endif
496	n/a	case FFI_TYPE_DOUBLE:
497	n/a	double_tmp = **p_argv.d;
498	n/a	if (fparg_count < NUM_FPR_ARG_REGISTERS64 && i < nfixedargs)
499	n/a	{
500	n/a	*fpr_base.d++ = double_tmp;
501	n/a	#if _CALL_ELF != 2
502	n/a	if ((flags & FLAG_COMPAT) != 0)
503	n/a	*next_arg.d = double_tmp;
504	n/a	#endif
505	n/a	}
506	n/a	else
507	n/a	*next_arg.d = double_tmp;
508	n/a	if (++next_arg.ul == gpr_end.ul)
509	n/a	next_arg.ul = rest.ul;
510	n/a	fparg_count++;
511	n/a	FFI_ASSERT (flags & FLAG_FP_ARGUMENTS);
512	n/a	break;
513	n/a
514	n/a	case FFI_TYPE_FLOAT:
515	n/a	double_tmp = **p_argv.f;
516	n/a	if (fparg_count < NUM_FPR_ARG_REGISTERS64 && i < nfixedargs)
517	n/a	{
518	n/a	*fpr_base.d++ = double_tmp;
519	n/a	#if _CALL_ELF != 2
520	n/a	if ((flags & FLAG_COMPAT) != 0)
521	n/a	*next_arg.f = (float) double_tmp;
522	n/a	#endif
523	n/a	}
524	n/a	else
525	n/a	*next_arg.f = (float) double_tmp;
526	n/a	if (++next_arg.ul == gpr_end.ul)
527	n/a	next_arg.ul = rest.ul;
528	n/a	fparg_count++;
529	n/a	FFI_ASSERT (flags & FLAG_FP_ARGUMENTS);
530	n/a	break;
531	n/a
532	n/a	case FFI_TYPE_STRUCT:
533	n/a	if ((ecif->cif->abi & FFI_LINUX_STRUCT_ALIGN) != 0)
534	n/a	{
535	n/a	align = (*ptr)->alignment;
536	n/a	if (align > 16)
537	n/a	align = 16;
538	n/a	if (align > 1)
539	n/a	next_arg.p = ALIGN (next_arg.p, align);
540	n/a	}
541	n/a	#if _CALL_ELF == 2
542	n/a	elt = discover_homogeneous_aggregate (*ptr, &elnum);
543	n/a	if (elt)
544	n/a	{
545	n/a	union {
546	n/a	void *v;
547	n/a	float *f;
548	n/a	double *d;
549	n/a	} arg;
550	n/a
551	n/a	arg.v = *p_argv.v;
552	n/a	if (elt == FFI_TYPE_FLOAT)
553	n/a	{
554	n/a	do
555	n/a	{
556	n/a	double_tmp = *arg.f++;
557	n/a	if (fparg_count < NUM_FPR_ARG_REGISTERS64
558	n/a	&& i < nfixedargs)
559	n/a	*fpr_base.d++ = double_tmp;
560	n/a	else
561	n/a	*next_arg.f = (float) double_tmp;
562	n/a	if (++next_arg.f == gpr_end.f)
563	n/a	next_arg.f = rest.f;
564	n/a	fparg_count++;
565	n/a	}
566	n/a	while (--elnum != 0);
567	n/a	if ((next_arg.p & 3) != 0)
568	n/a	{
569	n/a	if (++next_arg.f == gpr_end.f)
570	n/a	next_arg.f = rest.f;
571	n/a	}
572	n/a	}
573	n/a	else
574	n/a	do
575	n/a	{
576	n/a	double_tmp = *arg.d++;
577	n/a	if (fparg_count < NUM_FPR_ARG_REGISTERS64 && i < nfixedargs)
578	n/a	*fpr_base.d++ = double_tmp;
579	n/a	else
580	n/a	*next_arg.d = double_tmp;
581	n/a	if (++next_arg.d == gpr_end.d)
582	n/a	next_arg.d = rest.d;
583	n/a	fparg_count++;
584	n/a	}
585	n/a	while (--elnum != 0);
586	n/a	}
587	n/a	else
588	n/a	#endif
589	n/a	{
590	n/a	words = ((*ptr)->size + 7) / 8;
591	n/a	if (next_arg.ul >= gpr_base.ul && next_arg.ul + words > gpr_end.ul)
592	n/a	{
593	n/a	size_t first = gpr_end.c - next_arg.c;
594	n/a	memcpy (next_arg.c, *p_argv.c, first);
595	n/a	memcpy (rest.c, p_argv.c + first, (ptr)->size - first);
596	n/a	next_arg.c = rest.c + words * 8 - first;
597	n/a	}
598	n/a	else
599	n/a	{
600	n/a	char *where = next_arg.c;
601	n/a
602	n/a	#ifndef __LITTLE_ENDIAN__
603	n/a	/* Structures with size less than eight bytes are passed
604	n/a	left-padded. */
605	n/a	if ((*ptr)->size < 8)
606	n/a	where += 8 - (*ptr)->size;
607	n/a	#endif
608	n/a	memcpy (where, p_argv.c, (ptr)->size);
609	n/a	next_arg.ul += words;
610	n/a	if (next_arg.ul == gpr_end.ul)
611	n/a	next_arg.ul = rest.ul;
612	n/a	}
613	n/a	}
614	n/a	break;
615	n/a
616	n/a	case FFI_TYPE_UINT8:
617	n/a	gprvalue = **p_argv.uc;
618	n/a	goto putgpr;
619	n/a	case FFI_TYPE_SINT8:
620	n/a	gprvalue = **p_argv.sc;
621	n/a	goto putgpr;
622	n/a	case FFI_TYPE_UINT16:
623	n/a	gprvalue = **p_argv.us;
624	n/a	goto putgpr;
625	n/a	case FFI_TYPE_SINT16:
626	n/a	gprvalue = **p_argv.ss;
627	n/a	goto putgpr;
628	n/a	case FFI_TYPE_UINT32:
629	n/a	gprvalue = **p_argv.ui;
630	n/a	goto putgpr;
631	n/a	case FFI_TYPE_INT:
632	n/a	case FFI_TYPE_SINT32:
633	n/a	gprvalue = **p_argv.si;
634	n/a	goto putgpr;
635	n/a
636	n/a	case FFI_TYPE_UINT64:
637	n/a	case FFI_TYPE_SINT64:
638	n/a	case FFI_TYPE_POINTER:
639	n/a	gprvalue = **p_argv.ul;
640	n/a	putgpr:
641	n/a	*next_arg.ul++ = gprvalue;
642	n/a	if (next_arg.ul == gpr_end.ul)
643	n/a	next_arg.ul = rest.ul;
644	n/a	break;
645	n/a	}
646	n/a	}
647	n/a
648	n/a	FFI_ASSERT (flags & FLAG_4_GPR_ARGUMENTS
649	n/a	\|\| (next_arg.ul >= gpr_base.ul
650	n/a	&& next_arg.ul <= gpr_base.ul + 4));
651	n/a	}
652	n/a
653	n/a
654	n/a	#if _CALL_ELF == 2
655	n/a	#define MIN_CACHE_LINE_SIZE 8
656	n/a
657	n/a	static void
658	n/a	flush_icache (char wraddr, char xaddr, int size)
659	n/a	{
660	n/a	int i;
661	n/a	for (i = 0; i < size; i += MIN_CACHE_LINE_SIZE)
662	n/a	__asm__ volatile ("icbi 0,%0;" "dcbf 0,%1;"
663	n/a	: : "r" (xaddr + i), "r" (wraddr + i) : "memory");
664	n/a	__asm__ volatile ("icbi 0,%0;" "dcbf 0,%1;" "sync;" "isync;"
665	n/a	: : "r"(xaddr + size - 1), "r"(wraddr + size - 1)
666	n/a	: "memory");
667	n/a	}
668	n/a	#endif
669	n/a
670	n/a	ffi_status
671	n/a	ffi_prep_closure_loc_linux64 (ffi_closure *closure,
672	n/a	ffi_cif *cif,
673	n/a	void (fun) (ffi_cif , void , void , void ),
674	n/a	void *user_data,
675	n/a	void *codeloc)
676	n/a	{
677	n/a	#if _CALL_ELF == 2
678	n/a	unsigned int tramp = (unsigned int ) &closure->tramp[0];
679	n/a
680	n/a	if (cif->abi < FFI_LINUX \|\| cif->abi >= FFI_LAST_ABI)
681	n/a	return FFI_BAD_ABI;
682	n/a
683	n/a	tramp[0] = 0xe96c0018; /* 0: ld 11,2f-0b(12) */
684	n/a	tramp[1] = 0xe98c0010; /* ld 12,1f-0b(12) */
685	n/a	tramp[2] = 0x7d8903a6; /* mtctr 12 */
686	n/a	tramp[3] = 0x4e800420; /* bctr */
687	n/a	/* 1: .quad function_addr */
688	n/a	/* 2: .quad context */
689	n/a	(void ) &tramp[4] = (void ) ffi_closure_LINUX64;
690	n/a	(void *) &tramp[6] = codeloc;
691	n/a	flush_icache ((char )tramp, (char )codeloc, FFI_TRAMPOLINE_SIZE);
692	n/a	#else
693	n/a	void tramp = (void ) &closure->tramp[0];
694	n/a
695	n/a	if (cif->abi < FFI_LINUX \|\| cif->abi >= FFI_LAST_ABI)
696	n/a	return FFI_BAD_ABI;
697	n/a
698	n/a	/* Copy function address and TOC from ffi_closure_LINUX64. */
699	n/a	memcpy (tramp, (char *) ffi_closure_LINUX64, 16);
700	n/a	tramp[2] = tramp[1];
701	n/a	tramp[1] = codeloc;
702	n/a	#endif
703	n/a
704	n/a	closure->cif = cif;
705	n/a	closure->fun = fun;
706	n/a	closure->user_data = user_data;
707	n/a
708	n/a	return FFI_OK;
709	n/a	}
710	n/a
711	n/a
712	n/a	int FFI_HIDDEN
713	n/a	ffi_closure_helper_LINUX64 (ffi_closure closure, void rvalue,
714	n/a	unsigned long pst, ffi_dblfl pfr)
715	n/a	{
716	n/a	/* rvalue is the pointer to space for return value in closure assembly */
717	n/a	/* pst is the pointer to parameter save area
718	n/a	(r3-r10 are stored into its first 8 slots by ffi_closure_LINUX64) */
719	n/a	/* pfr is the pointer to where f1-f13 are stored in ffi_closure_LINUX64 */
720	n/a
721	n/a	void **avalue;
722	n/a	ffi_type **arg_types;
723	n/a	unsigned long i, avn, nfixedargs;
724	n/a	ffi_cif *cif;
725	n/a	ffi_dblfl *end_pfr = pfr + NUM_FPR_ARG_REGISTERS64;
726	n/a	unsigned long align;
727	n/a
728	n/a	cif = closure->cif;
729	n/a	avalue = alloca (cif->nargs * sizeof (void *));
730	n/a
731	n/a	/* Copy the caller's structure return value address so that the
732	n/a	closure returns the data directly to the caller. */
733	n/a	if (cif->rtype->type == FFI_TYPE_STRUCT
734	n/a	&& (cif->flags & FLAG_RETURNS_SMST) == 0)
735	n/a	{
736	n/a	rvalue = (void ) pst;
737	n/a	pst++;
738	n/a	}
739	n/a
740	n/a	i = 0;
741	n/a	avn = cif->nargs;
742	n/a	#if _CALL_ELF != 2
743	n/a	nfixedargs = (unsigned) -1;
744	n/a	if ((cif->flags & FLAG_COMPAT) == 0)
745	n/a	#endif
746	n/a	nfixedargs = cif->nfixedargs;
747	n/a	arg_types = cif->arg_types;
748	n/a
749	n/a	/* Grab the addresses of the arguments from the stack frame. */
750	n/a	while (i < avn)
751	n/a	{
752	n/a	unsigned int elt, elnum;
753	n/a
754	n/a	switch (arg_types[i]->type)
755	n/a	{
756	n/a	case FFI_TYPE_SINT8:
757	n/a	case FFI_TYPE_UINT8:
758	n/a	#ifndef __LITTLE_ENDIAN__
759	n/a	avalue[i] = (char *) pst + 7;
760	n/a	pst++;
761	n/a	break;
762	n/a	#endif
763	n/a
764	n/a	case FFI_TYPE_SINT16:
765	n/a	case FFI_TYPE_UINT16:
766	n/a	#ifndef __LITTLE_ENDIAN__
767	n/a	avalue[i] = (char *) pst + 6;
768	n/a	pst++;
769	n/a	break;
770	n/a	#endif
771	n/a
772	n/a	case FFI_TYPE_SINT32:
773	n/a	case FFI_TYPE_UINT32:
774	n/a	#ifndef __LITTLE_ENDIAN__
775	n/a	avalue[i] = (char *) pst + 4;
776	n/a	pst++;
777	n/a	break;
778	n/a	#endif
779	n/a
780	n/a	case FFI_TYPE_SINT64:
781	n/a	case FFI_TYPE_UINT64:
782	n/a	case FFI_TYPE_POINTER:
783	n/a	avalue[i] = pst;
784	n/a	pst++;
785	n/a	break;
786	n/a
787	n/a	case FFI_TYPE_STRUCT:
788	n/a	if ((cif->abi & FFI_LINUX_STRUCT_ALIGN) != 0)
789	n/a	{
790	n/a	align = arg_types[i]->alignment;
791	n/a	if (align > 16)
792	n/a	align = 16;
793	n/a	if (align > 1)
794	n/a	pst = (unsigned long *) ALIGN ((size_t) pst, align);
795	n/a	}
796	n/a	elt = 0;
797	n/a	#if _CALL_ELF == 2
798	n/a	elt = discover_homogeneous_aggregate (arg_types[i], &elnum);
799	n/a	#endif
800	n/a	if (elt)
801	n/a	{
802	n/a	union {
803	n/a	void *v;
804	n/a	unsigned long *ul;
805	n/a	float *f;
806	n/a	double *d;
807	n/a	size_t p;
808	n/a	} to, from;
809	n/a
810	n/a	/* Repackage the aggregate from its parts. The
811	n/a	aggregate size is not greater than the space taken by
812	n/a	the registers so store back to the register/parameter
813	n/a	save arrays. */
814	n/a	if (pfr + elnum <= end_pfr)
815	n/a	to.v = pfr;
816	n/a	else
817	n/a	to.v = pst;
818	n/a
819	n/a	avalue[i] = to.v;
820	n/a	from.ul = pst;
821	n/a	if (elt == FFI_TYPE_FLOAT)
822	n/a	{
823	n/a	do
824	n/a	{
825	n/a	if (pfr < end_pfr && i < nfixedargs)
826	n/a	{
827	n/a	*to.f = (float) pfr->d;
828	n/a	pfr++;
829	n/a	}
830	n/a	else
831	n/a	to.f = from.f;
832	n/a	to.f++;
833	n/a	from.f++;
834	n/a	}
835	n/a	while (--elnum != 0);
836	n/a	}
837	n/a	else
838	n/a	{
839	n/a	do
840	n/a	{
841	n/a	if (pfr < end_pfr && i < nfixedargs)
842	n/a	{
843	n/a	*to.d = pfr->d;
844	n/a	pfr++;
845	n/a	}
846	n/a	else
847	n/a	to.d = from.d;
848	n/a	to.d++;
849	n/a	from.d++;
850	n/a	}
851	n/a	while (--elnum != 0);
852	n/a	}
853	n/a	}
854	n/a	else
855	n/a	{
856	n/a	#ifndef __LITTLE_ENDIAN__
857	n/a	/* Structures with size less than eight bytes are passed
858	n/a	left-padded. */
859	n/a	if (arg_types[i]->size < 8)
860	n/a	avalue[i] = (char *) pst + 8 - arg_types[i]->size;
861	n/a	else
862	n/a	#endif
863	n/a	avalue[i] = pst;
864	n/a	}
865	n/a	pst += (arg_types[i]->size + 7) / 8;
866	n/a	break;
867	n/a
868	n/a	#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
869	n/a	case FFI_TYPE_LONGDOUBLE:
870	n/a	if ((cif->abi & FFI_LINUX_LONG_DOUBLE_128) != 0)
871	n/a	{
872	n/a	if (pfr + 1 < end_pfr && i + 1 < nfixedargs)
873	n/a	{
874	n/a	avalue[i] = pfr;
875	n/a	pfr += 2;
876	n/a	}
877	n/a	else
878	n/a	{
879	n/a	if (pfr < end_pfr && i < nfixedargs)
880	n/a	{
881	n/a	/* Passed partly in f13 and partly on the stack.
882	n/a	Move it all to the stack. */
883	n/a	pst = (unsigned long *) pfr;
884	n/a	pfr++;
885	n/a	}
886	n/a	avalue[i] = pst;
887	n/a	}
888	n/a	pst += 2;
889	n/a	break;
890	n/a	}
891	n/a	/* Fall through. */
892	n/a	#endif
893	n/a	case FFI_TYPE_DOUBLE:
894	n/a	/* On the outgoing stack all values are aligned to 8 */
895	n/a	/* there are 13 64bit floating point registers */
896	n/a
897	n/a	if (pfr < end_pfr && i < nfixedargs)
898	n/a	{
899	n/a	avalue[i] = pfr;
900	n/a	pfr++;
901	n/a	}
902	n/a	else
903	n/a	avalue[i] = pst;
904	n/a	pst++;
905	n/a	break;
906	n/a
907	n/a	case FFI_TYPE_FLOAT:
908	n/a	if (pfr < end_pfr && i < nfixedargs)
909	n/a	{
910	n/a	/* Float values are stored as doubles in the
911	n/a	ffi_closure_LINUX64 code. Fix them here. */
912	n/a	pfr->f = (float) pfr->d;
913	n/a	avalue[i] = pfr;
914	n/a	pfr++;
915	n/a	}
916	n/a	else
917	n/a	avalue[i] = pst;
918	n/a	pst++;
919	n/a	break;
920	n/a
921	n/a	default:
922	n/a	FFI_ASSERT (0);
923	n/a	}
924	n/a
925	n/a	i++;
926	n/a	}
927	n/a
928	n/a
929	n/a	(closure->fun) (cif, rvalue, avalue, closure->user_data);
930	n/a
931	n/a	/* Tell ffi_closure_LINUX64 how to perform return type promotions. */
932	n/a	if ((cif->flags & FLAG_RETURNS_SMST) != 0)
933	n/a	{
934	n/a	if ((cif->flags & FLAG_RETURNS_FP) == 0)
935	n/a	return FFI_V2_TYPE_SMALL_STRUCT + cif->rtype->size - 1;
936	n/a	else if ((cif->flags & FLAG_RETURNS_64BITS) != 0)
937	n/a	return FFI_V2_TYPE_DOUBLE_HOMOG;
938	n/a	else
939	n/a	return FFI_V2_TYPE_FLOAT_HOMOG;
940	n/a	}
941	n/a	return cif->rtype->type;
942	n/a	}
943	n/a	#endif