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

#	count	content
1	n/a	/* -----------------------------------------------------------------------
2	n/a	ffi_darwin.c
3	n/a
4	n/a	Copyright (C) 1998 Geoffrey Keating
5	n/a	Copyright (C) 2001 John Hornkvist
6	n/a	Copyright (C) 2002, 2006, 2007, 2009, 2010 Free Software Foundation, Inc.
7	n/a
8	n/a	FFI support for Darwin and AIX.
9	n/a
10	n/a	Permission is hereby granted, free of charge, to any person obtaining
11	n/a	a copy of this software and associated documentation files (the
12	n/a	``Software''), to deal in the Software without restriction, including
13	n/a	without limitation the rights to use, copy, modify, merge, publish,
14	n/a	distribute, sublicense, and/or sell copies of the Software, and to
15	n/a	permit persons to whom the Software is furnished to do so, subject to
16	n/a	the following conditions:
17	n/a
18	n/a	The above copyright notice and this permission notice shall be included
19	n/a	in all copies or substantial portions of the Software.
20	n/a
21	n/a	THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, EXPRESS
22	n/a	OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
23	n/a	MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
24	n/a	IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR
25	n/a	OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
26	n/a	ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
27	n/a	OTHER DEALINGS IN THE SOFTWARE.
28	n/a	----------------------------------------------------------------------- */
29	n/a
30	n/a	#include <ffi.h>
31	n/a	#include <ffi_common.h>
32	n/a
33	n/a	#include <stdlib.h>
34	n/a
35	n/a	extern void ffi_closure_ASM (void);
36	n/a
37	n/a	enum {
38	n/a	/* The assembly depends on these exact flags.
39	n/a	For Darwin64 (when FLAG_RETURNS_STRUCT is set):
40	n/a	FLAG_RETURNS_FP indicates that the structure embeds FP data.
41	n/a	FLAG_RETURNS_128BITS signals a special struct size that is not
42	n/a	expanded for float content. */
43	n/a	FLAG_RETURNS_128BITS = 1 << (31-31), /* These go in cr7 */
44	n/a	FLAG_RETURNS_NOTHING = 1 << (31-30),
45	n/a	FLAG_RETURNS_FP = 1 << (31-29),
46	n/a	FLAG_RETURNS_64BITS = 1 << (31-28),
47	n/a
48	n/a	FLAG_RETURNS_STRUCT = 1 << (31-27), /* This goes in cr6 */
49	n/a
50	n/a	FLAG_ARG_NEEDS_COPY = 1 << (31- 7),
51	n/a	FLAG_FP_ARGUMENTS = 1 << (31- 6), /* cr1.eq; specified by ABI */
52	n/a	FLAG_4_GPR_ARGUMENTS = 1 << (31- 5),
53	n/a	FLAG_RETVAL_REFERENCE = 1 << (31- 4)
54	n/a	};
55	n/a
56	n/a	/* About the DARWIN ABI. */
57	n/a	enum {
58	n/a	NUM_GPR_ARG_REGISTERS = 8,
59	n/a	NUM_FPR_ARG_REGISTERS = 13,
60	n/a	LINKAGE_AREA_GPRS = 6
61	n/a	};
62	n/a
63	n/a	enum { ASM_NEEDS_REGISTERS = 4 }; /* r28-r31 */
64	n/a
65	n/a	/* ffi_prep_args is called by the assembly routine once stack space
66	n/a	has been allocated for the function's arguments.
67	n/a
68	n/a	m32/m64
69	n/a
70	n/a	The stack layout we want looks like this:
71	n/a
72	n/a	\| Return address from ffi_call_DARWIN \| higher addresses
73	n/a	\|--------------------------------------------\|
74	n/a	\| Previous backchain pointer 4/8 \| stack pointer here
75	n/a	\|--------------------------------------------\|<+ <<< on entry to
76	n/a	\| ASM_NEEDS_REGISTERS=r28-r31 4*(4/8) \| \| ffi_call_DARWIN
77	n/a	\|--------------------------------------------\| \|
78	n/a	\| When we have any FP activity... the \| \|
79	n/a	\| FPRs occupy NUM_FPR_ARG_REGISTERS slots \| \|
80	n/a	\| here fp13 .. fp1 from high to low addr. \| \|
81	n/a	~ ~ ~
82	n/a	\| Parameters (at least 8*4/8=32/64) \| \| NUM_GPR_ARG_REGISTERS
83	n/a	\|--------------------------------------------\| \|
84	n/a	\| TOC=R2 (AIX) Reserved (Darwin) 4/8 \| \|
85	n/a	\|--------------------------------------------\| \| stack \|
86	n/a	\| Reserved 2*4/8 \| \| grows \|
87	n/a	\|--------------------------------------------\| \| down V
88	n/a	\| Space for callee's LR 4/8 \| \|
89	n/a	\|--------------------------------------------\| \| lower addresses
90	n/a	\| Saved CR [low word for m64] 4/8 \| \|
91	n/a	\|--------------------------------------------\| \| stack pointer here
92	n/a	\| Current backchain pointer 4/8 \|-/ during
93	n/a	\|--------------------------------------------\| <<< ffi_call_DARWIN
94	n/a
95	n/a	*/
96	n/a
97	n/a	#if defined(POWERPC_DARWIN64)
98	n/a	static void
99	n/a	darwin64_pass_struct_by_value
100	n/a	(ffi_type , char , unsigned, unsigned , double , unsigned long *);
101	n/a	#endif
102	n/a
103	n/a	/* This depends on GPR_SIZE = sizeof (unsigned long) */
104	n/a
105	n/a	void
106	n/a	ffi_prep_args (extended_cif ecif, unsigned long const stack)
107	n/a	{
108	n/a	const unsigned bytes = ecif->cif->bytes;
109	n/a	const unsigned flags = ecif->cif->flags;
110	n/a	const unsigned nargs = ecif->cif->nargs;
111	n/a	#if !defined(POWERPC_DARWIN64)
112	n/a	const ffi_abi abi = ecif->cif->abi;
113	n/a	#endif
114	n/a
115	n/a	/* 'stacktop' points at the previous backchain pointer. */
116	n/a	unsigned long *const stacktop = stack + (bytes / sizeof(unsigned long));
117	n/a
118	n/a	/* 'fpr_base' points at the space for fpr1, and grows upwards as
119	n/a	we use FPR registers. */
120	n/a	double fpr_base = (double ) (stacktop - ASM_NEEDS_REGISTERS) - NUM_FPR_ARG_REGISTERS;
121	n/a	int gp_count = 0, fparg_count = 0;
122	n/a
123	n/a	/* 'next_arg' grows up as we put parameters in it. */
124	n/a	unsigned long next_arg = stack + LINKAGE_AREA_GPRS; / 6 reserved positions. */
125	n/a
126	n/a	int i;
127	n/a	double double_tmp;
128	n/a	void **p_argv = ecif->avalue;
129	n/a	unsigned long gprvalue;
130	n/a	ffi_type** ptr = ecif->cif->arg_types;
131	n/a	#if !defined(POWERPC_DARWIN64)
132	n/a	char *dest_cpy;
133	n/a	#endif
134	n/a	unsigned size_al = 0;
135	n/a
136	n/a	/* Check that everything starts aligned properly. */
137	n/a	FFI_ASSERT(((unsigned) (char *) stack & 0xF) == 0);
138	n/a	FFI_ASSERT(((unsigned) (char *) stacktop & 0xF) == 0);
139	n/a	FFI_ASSERT((bytes & 0xF) == 0);
140	n/a
141	n/a	/* Deal with return values that are actually pass-by-reference.
142	n/a	Rule:
143	n/a	Return values are referenced by r3, so r4 is the first parameter. */
144	n/a
145	n/a	if (flags & FLAG_RETVAL_REFERENCE)
146	n/a	next_arg++ = (unsigned long) (char ) ecif->rvalue;
147	n/a
148	n/a	/* Now for the arguments. */
149	n/a	for (i = nargs; i > 0; i--, ptr++, p_argv++)
150	n/a	{
151	n/a	switch ((*ptr)->type)
152	n/a	{
153	n/a	/* If a floating-point parameter appears before all of the general-
154	n/a	purpose registers are filled, the corresponding GPRs that match
155	n/a	the size of the floating-point parameter are skipped. */
156	n/a	case FFI_TYPE_FLOAT:
157	n/a	double_tmp = (float ) *p_argv;
158	n/a	if (fparg_count < NUM_FPR_ARG_REGISTERS)
159	n/a	*fpr_base++ = double_tmp;
160	n/a	#if defined(POWERPC_DARWIN)
161	n/a	(float )next_arg = (float ) *p_argv;
162	n/a	#else
163	n/a	(double )next_arg = double_tmp;
164	n/a	#endif
165	n/a	next_arg++;
166	n/a	gp_count++;
167	n/a	fparg_count++;
168	n/a	FFI_ASSERT(flags & FLAG_FP_ARGUMENTS);
169	n/a	break;
170	n/a
171	n/a	case FFI_TYPE_DOUBLE:
172	n/a	double_tmp = (double ) *p_argv;
173	n/a	if (fparg_count < NUM_FPR_ARG_REGISTERS)
174	n/a	*fpr_base++ = double_tmp;
175	n/a	(double )next_arg = double_tmp;
176	n/a	#ifdef POWERPC64
177	n/a	next_arg++;
178	n/a	gp_count++;
179	n/a	#else
180	n/a	next_arg += 2;
181	n/a	gp_count += 2;
182	n/a	#endif
183	n/a	fparg_count++;
184	n/a	FFI_ASSERT(flags & FLAG_FP_ARGUMENTS);
185	n/a	break;
186	n/a
187	n/a	#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
188	n/a
189	n/a	case FFI_TYPE_LONGDOUBLE:
190	n/a	# if defined(POWERPC64) && !defined(POWERPC_DARWIN64)
191	n/a	/* ??? This will exceed the regs count when the value starts at fp13
192	n/a	and it will not put the extra bit on the stack. */
193	n/a	if (fparg_count < NUM_FPR_ARG_REGISTERS)
194	n/a	(long double ) fpr_base++ = (long double ) *p_argv;
195	n/a	else
196	n/a	(long double ) next_arg = (long double ) *p_argv;
197	n/a	next_arg += 2;
198	n/a	fparg_count += 2;
199	n/a	# else
200	n/a	double_tmp = ((double ) p_argv)[0];
201	n/a	if (fparg_count < NUM_FPR_ARG_REGISTERS)
202	n/a	*fpr_base++ = double_tmp;
203	n/a	(double ) next_arg = double_tmp;
204	n/a	# if defined(POWERPC_DARWIN64)
205	n/a	next_arg++;
206	n/a	gp_count++;
207	n/a	# else
208	n/a	next_arg += 2;
209	n/a	gp_count += 2;
210	n/a	# endif
211	n/a	fparg_count++;
212	n/a	double_tmp = ((double ) p_argv)[1];
213	n/a	if (fparg_count < NUM_FPR_ARG_REGISTERS)
214	n/a	*fpr_base++ = double_tmp;
215	n/a	(double ) next_arg = double_tmp;
216	n/a	# if defined(POWERPC_DARWIN64)
217	n/a	next_arg++;
218	n/a	gp_count++;
219	n/a	# else
220	n/a	next_arg += 2;
221	n/a	gp_count += 2;
222	n/a	# endif
223	n/a	fparg_count++;
224	n/a	# endif
225	n/a	FFI_ASSERT(flags & FLAG_FP_ARGUMENTS);
226	n/a	break;
227	n/a	#endif
228	n/a	case FFI_TYPE_UINT64:
229	n/a	case FFI_TYPE_SINT64:
230	n/a	#ifdef POWERPC64
231	n/a	gprvalue = (long long ) *p_argv;
232	n/a	goto putgpr;
233	n/a	#else
234	n/a	(long long ) next_arg = (long long ) *p_argv;
235	n/a	next_arg += 2;
236	n/a	gp_count += 2;
237	n/a	#endif
238	n/a	break;
239	n/a	case FFI_TYPE_POINTER:
240	n/a	gprvalue = (unsigned long ) *p_argv;
241	n/a	goto putgpr;
242	n/a	case FFI_TYPE_UINT8:
243	n/a	gprvalue = (unsigned char ) *p_argv;
244	n/a	goto putgpr;
245	n/a	case FFI_TYPE_SINT8:
246	n/a	gprvalue = (signed char ) *p_argv;
247	n/a	goto putgpr;
248	n/a	case FFI_TYPE_UINT16:
249	n/a	gprvalue = (unsigned short ) *p_argv;
250	n/a	goto putgpr;
251	n/a	case FFI_TYPE_SINT16:
252	n/a	gprvalue = (signed short ) *p_argv;
253	n/a	goto putgpr;
254	n/a
255	n/a	case FFI_TYPE_STRUCT:
256	n/a	size_al = (*ptr)->size;
257	n/a	#if defined(POWERPC_DARWIN64)
258	n/a	next_arg = (unsigned long )ALIGN((char )next_arg, (*ptr)->alignment);
259	n/a	darwin64_pass_struct_by_value (ptr, (char ) *p_argv,
260	n/a	(unsigned) size_al,
261	n/a	(unsigned int *) &fparg_count,
262	n/a	&fpr_base, &next_arg);
263	n/a	#else
264	n/a	dest_cpy = (char *) next_arg;
265	n/a
266	n/a	/* If the first member of the struct is a double, then include enough
267	n/a	padding in the struct size to align it to double-word. */
268	n/a	if ((*ptr)->elements[0]->type == FFI_TYPE_DOUBLE)
269	n/a	size_al = ALIGN((*ptr)->size, 8);
270	n/a
271	n/a	# if defined(POWERPC64)
272	n/a	FFI_ASSERT (abi != FFI_DARWIN);
273	n/a	memcpy ((char ) dest_cpy, (char ) *p_argv, size_al);
274	n/a	next_arg += (size_al + 7) / 8;
275	n/a	# else
276	n/a	/* Structures that match the basic modes (QI 1 byte, HI 2 bytes,
277	n/a	SI 4 bytes) are aligned as if they were those modes.
278	n/a	Structures with 3 byte in size are padded upwards. */
279	n/a	if (size_al < 3 && abi == FFI_DARWIN)
280	n/a	dest_cpy += 4 - size_al;
281	n/a
282	n/a	memcpy((char ) dest_cpy, (char ) *p_argv, size_al);
283	n/a	next_arg += (size_al + 3) / 4;
284	n/a	# endif
285	n/a	#endif
286	n/a	break;
287	n/a
288	n/a	case FFI_TYPE_INT:
289	n/a	case FFI_TYPE_SINT32:
290	n/a	gprvalue = (signed int ) *p_argv;
291	n/a	goto putgpr;
292	n/a
293	n/a	case FFI_TYPE_UINT32:
294	n/a	gprvalue = (unsigned int ) *p_argv;
295	n/a	putgpr:
296	n/a	*next_arg++ = gprvalue;
297	n/a	gp_count++;
298	n/a	break;
299	n/a	default:
300	n/a	break;
301	n/a	}
302	n/a	}
303	n/a
304	n/a	/* Check that we didn't overrun the stack... */
305	n/a	/* FFI_ASSERT(gpr_base <= stacktop - ASM_NEEDS_REGISTERS);
306	n/a	FFI_ASSERT((unsigned *)fpr_base
307	n/a	<= stacktop - ASM_NEEDS_REGISTERS - NUM_GPR_ARG_REGISTERS);
308	n/a	FFI_ASSERT(flags & FLAG_4_GPR_ARGUMENTS \|\| intarg_count <= 4); */
309	n/a	}
310	n/a
311	n/a	#if defined(POWERPC_DARWIN64)
312	n/a
313	n/a	/* See if we can put some of the struct into fprs.
314	n/a	This should not be called for structures of size 16 bytes, since these are not
315	n/a	broken out this way. */
316	n/a	static void
317	n/a	darwin64_scan_struct_for_floats (ffi_type s, unsigned nfpr)
318	n/a	{
319	n/a	int i;
320	n/a
321	n/a	FFI_ASSERT (s->type == FFI_TYPE_STRUCT)
322	n/a
323	n/a	for (i = 0; s->elements[i] != NULL; i++)
324	n/a	{
325	n/a	ffi_type *p = s->elements[i];
326	n/a	switch (p->type)
327	n/a	{
328	n/a	case FFI_TYPE_STRUCT:
329	n/a	darwin64_scan_struct_for_floats (p, nfpr);
330	n/a	break;
331	n/a	case FFI_TYPE_LONGDOUBLE:
332	n/a	(*nfpr) += 2;
333	n/a	break;
334	n/a	case FFI_TYPE_DOUBLE:
335	n/a	case FFI_TYPE_FLOAT:
336	n/a	(*nfpr) += 1;
337	n/a	break;
338	n/a	default:
339	n/a	break;
340	n/a	}
341	n/a	}
342	n/a	}
343	n/a
344	n/a	static int
345	n/a	darwin64_struct_size_exceeds_gprs_p (ffi_type s, char src, unsigned *nfpr)
346	n/a	{
347	n/a	unsigned struct_offset=0, i;
348	n/a
349	n/a	for (i = 0; s->elements[i] != NULL; i++)
350	n/a	{
351	n/a	char *item_base;
352	n/a	ffi_type *p = s->elements[i];
353	n/a	/* Find the start of this item (0 for the first one). */
354	n/a	if (i > 0)
355	n/a	struct_offset = ALIGN(struct_offset, p->alignment);
356	n/a
357	n/a	item_base = src + struct_offset;
358	n/a
359	n/a	switch (p->type)
360	n/a	{
361	n/a	case FFI_TYPE_STRUCT:
362	n/a	if (darwin64_struct_size_exceeds_gprs_p (p, item_base, nfpr))
363	n/a	return 1;
364	n/a	break;
365	n/a	case FFI_TYPE_LONGDOUBLE:
366	n/a	if (*nfpr >= NUM_FPR_ARG_REGISTERS)
367	n/a	return 1;
368	n/a	(*nfpr) += 1;
369	n/a	item_base += 8;
370	n/a	/* FALL THROUGH */
371	n/a	case FFI_TYPE_DOUBLE:
372	n/a	if (*nfpr >= NUM_FPR_ARG_REGISTERS)
373	n/a	return 1;
374	n/a	(*nfpr) += 1;
375	n/a	break;
376	n/a	case FFI_TYPE_FLOAT:
377	n/a	if (*nfpr >= NUM_FPR_ARG_REGISTERS)
378	n/a	return 1;
379	n/a	(*nfpr) += 1;
380	n/a	break;
381	n/a	default:
382	n/a	/* If we try and place any item, that is non-float, once we've
383	n/a	exceeded the 8 GPR mark, then we can't fit the struct. */
384	n/a	if ((unsigned long)item_base >= 8*8)
385	n/a	return 1;
386	n/a	break;
387	n/a	}
388	n/a	/* now count the size of what we just used. */
389	n/a	struct_offset += p->size;
390	n/a	}
391	n/a	return 0;
392	n/a	}
393	n/a
394	n/a	/* Can this struct be returned by value? */
395	n/a	int
396	n/a	darwin64_struct_ret_by_value_p (ffi_type *s)
397	n/a	{
398	n/a	unsigned nfp = 0;
399	n/a
400	n/a	FFI_ASSERT (s && s->type == FFI_TYPE_STRUCT);
401	n/a
402	n/a	/* The largest structure we can return is 8long + 13 doubles. */
403	n/a	if (s->size > 168)
404	n/a	return 0;
405	n/a
406	n/a	/* We can't pass more than 13 floats. */
407	n/a	darwin64_scan_struct_for_floats (s, &nfp);
408	n/a	if (nfp > 13)
409	n/a	return 0;
410	n/a
411	n/a	/* If there are not too many floats, and the struct is
412	n/a	small enough to accommodate in the GPRs, then it must be OK. */
413	n/a	if (s->size <= 64)
414	n/a	return 1;
415	n/a
416	n/a	/* Well, we have to look harder. */
417	n/a	nfp = 0;
418	n/a	if (darwin64_struct_size_exceeds_gprs_p (s, NULL, &nfp))
419	n/a	return 0;
420	n/a
421	n/a	return 1;
422	n/a	}
423	n/a
424	n/a	void
425	n/a	darwin64_pass_struct_floats (ffi_type s, char src,
426	n/a	unsigned nfpr, double *fprs)
427	n/a	{
428	n/a	int i;
429	n/a	double fpr_base = fprs;
430	n/a	unsigned struct_offset = 0;
431	n/a
432	n/a	/* We don't assume anything about the alignment of the source. */
433	n/a	for (i = 0; s->elements[i] != NULL; i++)
434	n/a	{
435	n/a	char *item_base;
436	n/a	ffi_type *p = s->elements[i];
437	n/a	/* Find the start of this item (0 for the first one). */
438	n/a	if (i > 0)
439	n/a	struct_offset = ALIGN(struct_offset, p->alignment);
440	n/a	item_base = src + struct_offset;
441	n/a
442	n/a	switch (p->type)
443	n/a	{
444	n/a	case FFI_TYPE_STRUCT:
445	n/a	darwin64_pass_struct_floats (p, item_base, nfpr,
446	n/a	&fpr_base);
447	n/a	break;
448	n/a	case FFI_TYPE_LONGDOUBLE:
449	n/a	if (*nfpr < NUM_FPR_ARG_REGISTERS)
450	n/a	fpr_base++ = (double *)item_base;
451	n/a	(*nfpr) += 1;
452	n/a	item_base += 8;
453	n/a	/* FALL THROUGH */
454	n/a	case FFI_TYPE_DOUBLE:
455	n/a	if (*nfpr < NUM_FPR_ARG_REGISTERS)
456	n/a	fpr_base++ = (double *)item_base;
457	n/a	(*nfpr) += 1;
458	n/a	break;
459	n/a	case FFI_TYPE_FLOAT:
460	n/a	if (*nfpr < NUM_FPR_ARG_REGISTERS)
461	n/a	fpr_base++ = (double) (float *)item_base;
462	n/a	(*nfpr) += 1;
463	n/a	break;
464	n/a	default:
465	n/a	break;
466	n/a	}
467	n/a	/* now count the size of what we just used. */
468	n/a	struct_offset += p->size;
469	n/a	}
470	n/a	/* Update the scores. */
471	n/a	*fprs = fpr_base;
472	n/a	}
473	n/a
474	n/a	/* Darwin64 special rules.
475	n/a	Break out a struct into params and float registers. */
476	n/a	static void
477	n/a	darwin64_pass_struct_by_value (ffi_type s, char src, unsigned size,
478	n/a	unsigned nfpr, double fprs, unsigned long *arg)
479	n/a	{
480	n/a	unsigned long next_arg = arg;
481	n/a	char dest_cpy = (char )next_arg;
482	n/a
483	n/a	FFI_ASSERT (s->type == FFI_TYPE_STRUCT)
484	n/a
485	n/a	if (!size)
486	n/a	return;
487	n/a
488	n/a	/* First... special cases. */
489	n/a	if (size < 3
490	n/a	\|\| (size == 4
491	n/a	&& s->elements[0]
492	n/a	&& s->elements[0]->type != FFI_TYPE_FLOAT))
493	n/a	{
494	n/a	/* Must be at least one GPR, padding is unspecified in value,
495	n/a	let's make it zero. */
496	n/a	*next_arg = 0UL;
497	n/a	dest_cpy += 8 - size;
498	n/a	memcpy ((char *) dest_cpy, src, size);
499	n/a	next_arg++;
500	n/a	}
501	n/a	else if (size == 16)
502	n/a	{
503	n/a	memcpy ((char *) dest_cpy, src, size);
504	n/a	next_arg += 2;
505	n/a	}
506	n/a	else
507	n/a	{
508	n/a	/* now the general case, we consider embedded floats. */
509	n/a	memcpy ((char *) dest_cpy, src, size);
510	n/a	darwin64_pass_struct_floats (s, src, nfpr, fprs);
511	n/a	next_arg += (size+7)/8;
512	n/a	}
513	n/a
514	n/a	*arg = next_arg;
515	n/a	}
516	n/a
517	n/a	double *
518	n/a	darwin64_struct_floats_to_mem (ffi_type s, char dest, double fprs, unsigned nf)
519	n/a	{
520	n/a	int i;
521	n/a	unsigned struct_offset = 0;
522	n/a
523	n/a	/* We don't assume anything about the alignment of the source. */
524	n/a	for (i = 0; s->elements[i] != NULL; i++)
525	n/a	{
526	n/a	char *item_base;
527	n/a	ffi_type *p = s->elements[i];
528	n/a	/* Find the start of this item (0 for the first one). */
529	n/a	if (i > 0)
530	n/a	struct_offset = ALIGN(struct_offset, p->alignment);
531	n/a	item_base = dest + struct_offset;
532	n/a
533	n/a	switch (p->type)
534	n/a	{
535	n/a	case FFI_TYPE_STRUCT:
536	n/a	fprs = darwin64_struct_floats_to_mem (p, item_base, fprs, nf);
537	n/a	break;
538	n/a	case FFI_TYPE_LONGDOUBLE:
539	n/a	if (*nf < NUM_FPR_ARG_REGISTERS)
540	n/a	{
541	n/a	(double )item_base = *fprs++ ;
542	n/a	(*nf) += 1;
543	n/a	}
544	n/a	item_base += 8;
545	n/a	/* FALL THROUGH */
546	n/a	case FFI_TYPE_DOUBLE:
547	n/a	if (*nf < NUM_FPR_ARG_REGISTERS)
548	n/a	{
549	n/a	(double )item_base = *fprs++ ;
550	n/a	(*nf) += 1;
551	n/a	}
552	n/a	break;
553	n/a	case FFI_TYPE_FLOAT:
554	n/a	if (*nf < NUM_FPR_ARG_REGISTERS)
555	n/a	{
556	n/a	(float )item_base = (float) *fprs++ ;
557	n/a	(*nf) += 1;
558	n/a	}
559	n/a	break;
560	n/a	default:
561	n/a	break;
562	n/a	}
563	n/a	/* now count the size of what we just used. */
564	n/a	struct_offset += p->size;
565	n/a	}
566	n/a	return fprs;
567	n/a	}
568	n/a
569	n/a	#endif
570	n/a
571	n/a	/* Adjust the size of S to be correct for Darwin.
572	n/a	On Darwin m32, the first field of a structure has natural alignment.
573	n/a	On Darwin m64, all fields have natural alignment. */
574	n/a
575	n/a	static void
576	n/a	darwin_adjust_aggregate_sizes (ffi_type *s)
577	n/a	{
578	n/a	int i;
579	n/a
580	n/a	if (s->type != FFI_TYPE_STRUCT)
581	n/a	return;
582	n/a
583	n/a	s->size = 0;
584	n/a	for (i = 0; s->elements[i] != NULL; i++)
585	n/a	{
586	n/a	ffi_type *p;
587	n/a	int align;
588	n/a
589	n/a	p = s->elements[i];
590	n/a	if (p->type == FFI_TYPE_STRUCT)
591	n/a	darwin_adjust_aggregate_sizes (p);
592	n/a	#if defined(POWERPC_DARWIN64)
593	n/a	/* Natural alignment for all items. */
594	n/a	align = p->alignment;
595	n/a	#else
596	n/a	/* Natural alignment for the first item... */
597	n/a	if (i == 0)
598	n/a	align = p->alignment;
599	n/a	else if (p->alignment == 16 \|\| p->alignment < 4)
600	n/a	/* .. subsequent items with vector or align < 4 have natural align. */
601	n/a	align = p->alignment;
602	n/a	else
603	n/a	/* .. or align is 4. */
604	n/a	align = 4;
605	n/a	#endif
606	n/a	/* Pad, if necessary, before adding the current item. */
607	n/a	s->size = ALIGN(s->size, align) + p->size;
608	n/a	}
609	n/a
610	n/a	s->size = ALIGN(s->size, s->alignment);
611	n/a
612	n/a	/* This should not be necessary on m64, but harmless. */
613	n/a	if (s->elements[0]->type == FFI_TYPE_UINT64
614	n/a	\|\| s->elements[0]->type == FFI_TYPE_SINT64
615	n/a	\|\| s->elements[0]->type == FFI_TYPE_DOUBLE
616	n/a	\|\| s->elements[0]->alignment == 8)
617	n/a	s->alignment = s->alignment > 8 ? s->alignment : 8;
618	n/a	/* Do not add additional tail padding. */
619	n/a	}
620	n/a
621	n/a	/* Adjust the size of S to be correct for AIX.
622	n/a	Word-align double unless it is the first member of a structure. */
623	n/a
624	n/a	static void
625	n/a	aix_adjust_aggregate_sizes (ffi_type *s)
626	n/a	{
627	n/a	int i;
628	n/a
629	n/a	if (s->type != FFI_TYPE_STRUCT)
630	n/a	return;
631	n/a
632	n/a	s->size = 0;
633	n/a	for (i = 0; s->elements[i] != NULL; i++)
634	n/a	{
635	n/a	ffi_type *p;
636	n/a	int align;
637	n/a
638	n/a	p = s->elements[i];
639	n/a	aix_adjust_aggregate_sizes (p);
640	n/a	align = p->alignment;
641	n/a	if (i != 0 && p->type == FFI_TYPE_DOUBLE)
642	n/a	align = 4;
643	n/a	s->size = ALIGN(s->size, align) + p->size;
644	n/a	}
645	n/a
646	n/a	s->size = ALIGN(s->size, s->alignment);
647	n/a
648	n/a	if (s->elements[0]->type == FFI_TYPE_UINT64
649	n/a	\|\| s->elements[0]->type == FFI_TYPE_SINT64
650	n/a	\|\| s->elements[0]->type == FFI_TYPE_DOUBLE
651	n/a	\|\| s->elements[0]->alignment == 8)
652	n/a	s->alignment = s->alignment > 8 ? s->alignment : 8;
653	n/a	/* Do not add additional tail padding. */
654	n/a	}
655	n/a
656	n/a	/* Perform machine dependent cif processing. */
657	n/a	ffi_status
658	n/a	ffi_prep_cif_machdep (ffi_cif *cif)
659	n/a	{
660	n/a	/* All this is for the DARWIN ABI. */
661	n/a	unsigned i;
662	n/a	ffi_type **ptr;
663	n/a	unsigned bytes;
664	n/a	unsigned fparg_count = 0, intarg_count = 0;
665	n/a	unsigned flags = 0;
666	n/a	unsigned size_al = 0;
667	n/a
668	n/a	/* All the machine-independent calculation of cif->bytes will be wrong.
669	n/a	All the calculation of structure sizes will also be wrong.
670	n/a	Redo the calculation for DARWIN. */
671	n/a
672	n/a	if (cif->abi == FFI_DARWIN)
673	n/a	{
674	n/a	darwin_adjust_aggregate_sizes (cif->rtype);
675	n/a	for (i = 0; i < cif->nargs; i++)
676	n/a	darwin_adjust_aggregate_sizes (cif->arg_types[i]);
677	n/a	}
678	n/a
679	n/a	if (cif->abi == FFI_AIX)
680	n/a	{
681	n/a	aix_adjust_aggregate_sizes (cif->rtype);
682	n/a	for (i = 0; i < cif->nargs; i++)
683	n/a	aix_adjust_aggregate_sizes (cif->arg_types[i]);
684	n/a	}
685	n/a
686	n/a	/* Space for the frame pointer, callee's LR, CR, etc, and for
687	n/a	the asm's temp regs. */
688	n/a
689	n/a	bytes = (LINKAGE_AREA_GPRS + ASM_NEEDS_REGISTERS) * sizeof(unsigned long);
690	n/a
691	n/a	/* Return value handling.
692	n/a	The rules m32 are as follows:
693	n/a	- 32-bit (or less) integer values are returned in gpr3;
694	n/a	- structures of size <= 4 bytes also returned in gpr3;
695	n/a	- 64-bit integer values [??? and structures between 5 and 8 bytes] are
696	n/a	returned in gpr3 and gpr4;
697	n/a	- Single/double FP values are returned in fpr1;
698	n/a	- Long double FP (if not equivalent to double) values are returned in
699	n/a	fpr1 and fpr2;
700	n/a	m64:
701	n/a	- 64-bit or smaller integral values are returned in GPR3
702	n/a	- Single/double FP values are returned in fpr1;
703	n/a	- Long double FP values are returned in fpr1 and fpr2;
704	n/a	m64 Structures:
705	n/a	- If the structure could be accommodated in registers were it to be the
706	n/a	first argument to a routine, then it is returned in those registers.
707	n/a	m32/m64 structures otherwise:
708	n/a	- Larger structures values are allocated space and a pointer is passed
709	n/a	as the first argument. */
710	n/a	switch (cif->rtype->type)
711	n/a	{
712	n/a
713	n/a	#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
714	n/a	case FFI_TYPE_LONGDOUBLE:
715	n/a	flags \|= FLAG_RETURNS_128BITS;
716	n/a	flags \|= FLAG_RETURNS_FP;
717	n/a	break;
718	n/a	#endif
719	n/a
720	n/a	case FFI_TYPE_DOUBLE:
721	n/a	flags \|= FLAG_RETURNS_64BITS;
722	n/a	/* Fall through. */
723	n/a	case FFI_TYPE_FLOAT:
724	n/a	flags \|= FLAG_RETURNS_FP;
725	n/a	break;
726	n/a
727	n/a	case FFI_TYPE_UINT64:
728	n/a	case FFI_TYPE_SINT64:
729	n/a	#ifdef POWERPC64
730	n/a	case FFI_TYPE_POINTER:
731	n/a	#endif
732	n/a	flags \|= FLAG_RETURNS_64BITS;
733	n/a	break;
734	n/a
735	n/a	case FFI_TYPE_STRUCT:
736	n/a	#if defined(POWERPC_DARWIN64)
737	n/a	{
738	n/a	/* Can we fit the struct into regs? */
739	n/a	if (darwin64_struct_ret_by_value_p (cif->rtype))
740	n/a	{
741	n/a	unsigned nfpr = 0;
742	n/a	flags \|= FLAG_RETURNS_STRUCT;
743	n/a	if (cif->rtype->size != 16)
744	n/a	darwin64_scan_struct_for_floats (cif->rtype, &nfpr) ;
745	n/a	else
746	n/a	flags \|= FLAG_RETURNS_128BITS;
747	n/a	/* Will be 0 for 16byte struct. */
748	n/a	if (nfpr)
749	n/a	flags \|= FLAG_RETURNS_FP;
750	n/a	}
751	n/a	else /* By ref. */
752	n/a	{
753	n/a	flags \|= FLAG_RETVAL_REFERENCE;
754	n/a	flags \|= FLAG_RETURNS_NOTHING;
755	n/a	intarg_count++;
756	n/a	}
757	n/a	}
758	n/a	#elif defined(DARWIN_PPC)
759	n/a	if (cif->rtype->size <= 4)
760	n/a	flags \|= FLAG_RETURNS_STRUCT;
761	n/a	else /* else by reference. */
762	n/a	{
763	n/a	flags \|= FLAG_RETVAL_REFERENCE;
764	n/a	flags \|= FLAG_RETURNS_NOTHING;
765	n/a	intarg_count++;
766	n/a	}
767	n/a	#else /* assume we pass by ref. */
768	n/a	flags \|= FLAG_RETVAL_REFERENCE;
769	n/a	flags \|= FLAG_RETURNS_NOTHING;
770	n/a	intarg_count++;
771	n/a	#endif
772	n/a	break;
773	n/a	case FFI_TYPE_VOID:
774	n/a	flags \|= FLAG_RETURNS_NOTHING;
775	n/a	break;
776	n/a
777	n/a	default:
778	n/a	/* Returns 32-bit integer, or similar. Nothing to do here. */
779	n/a	break;
780	n/a	}
781	n/a
782	n/a	/* The first NUM_GPR_ARG_REGISTERS words of integer arguments, and the
783	n/a	first NUM_FPR_ARG_REGISTERS fp arguments, go in registers; the rest
784	n/a	goes on the stack.
785	n/a	??? Structures are passed as a pointer to a copy of the structure.
786	n/a	Stuff on the stack needs to keep proper alignment.
787	n/a	For m64 the count is effectively of half-GPRs. */
788	n/a	for (ptr = cif->arg_types, i = cif->nargs; i > 0; i--, ptr++)
789	n/a	{
790	n/a	unsigned align_words;
791	n/a	switch ((*ptr)->type)
792	n/a	{
793	n/a	case FFI_TYPE_FLOAT:
794	n/a	case FFI_TYPE_DOUBLE:
795	n/a	fparg_count++;
796	n/a	#if !defined(POWERPC_DARWIN64)
797	n/a	/* If this FP arg is going on the stack, it must be
798	n/a	8-byte-aligned. */
799	n/a	if (fparg_count > NUM_FPR_ARG_REGISTERS
800	n/a	&& (intarg_count & 0x01) != 0)
801	n/a	intarg_count++;
802	n/a	#endif
803	n/a	break;
804	n/a
805	n/a	#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
806	n/a	case FFI_TYPE_LONGDOUBLE:
807	n/a	fparg_count += 2;
808	n/a	/* If this FP arg is going on the stack, it must be
809	n/a	16-byte-aligned. */
810	n/a	if (fparg_count >= NUM_FPR_ARG_REGISTERS)
811	n/a	#if defined (POWERPC64)
812	n/a	intarg_count = ALIGN(intarg_count, 2);
813	n/a	#else
814	n/a	intarg_count = ALIGN(intarg_count, 4);
815	n/a	#endif
816	n/a	break;
817	n/a	#endif
818	n/a
819	n/a	case FFI_TYPE_UINT64:
820	n/a	case FFI_TYPE_SINT64:
821	n/a	#if defined(POWERPC64)
822	n/a	intarg_count++;
823	n/a	#else
824	n/a	/* 'long long' arguments are passed as two words, but
825	n/a	either both words must fit in registers or both go
826	n/a	on the stack. If they go on the stack, they must
827	n/a	be 8-byte-aligned. */
828	n/a	if (intarg_count == NUM_GPR_ARG_REGISTERS-1
829	n/a	\|\| (intarg_count >= NUM_GPR_ARG_REGISTERS
830	n/a	&& (intarg_count & 0x01) != 0))
831	n/a	intarg_count++;
832	n/a	intarg_count += 2;
833	n/a	#endif
834	n/a	break;
835	n/a
836	n/a	case FFI_TYPE_STRUCT:
837	n/a	size_al = (*ptr)->size;
838	n/a	#if defined(POWERPC_DARWIN64)
839	n/a	align_words = (*ptr)->alignment >> 3;
840	n/a	if (align_words)
841	n/a	intarg_count = ALIGN(intarg_count, align_words);
842	n/a	/* Base size of the struct. */
843	n/a	intarg_count += (size_al + 7) / 8;
844	n/a	/* If 16 bytes then don't worry about floats. */
845	n/a	if (size_al != 16)
846	n/a	/* Scan through for floats to be placed in regs. */
847	n/a	darwin64_scan_struct_for_floats (*ptr, &fparg_count) ;
848	n/a	#else
849	n/a	align_words = (*ptr)->alignment >> 2;
850	n/a	if (align_words)
851	n/a	intarg_count = ALIGN(intarg_count, align_words);
852	n/a	/* If the first member of the struct is a double, then align
853	n/a	the struct to double-word.
854	n/a	if ((*ptr)->elements[0]->type == FFI_TYPE_DOUBLE)
855	n/a	size_al = ALIGN((ptr)->size, 8); /
856	n/a	# ifdef POWERPC64
857	n/a	intarg_count += (size_al + 7) / 8;
858	n/a	# else
859	n/a	intarg_count += (size_al + 3) / 4;
860	n/a	# endif
861	n/a	#endif
862	n/a	break;
863	n/a
864	n/a	default:
865	n/a	/* Everything else is passed as a 4-byte word in a GPR, either
866	n/a	the object itself or a pointer to it. */
867	n/a	intarg_count++;
868	n/a	break;
869	n/a	}
870	n/a	}
871	n/a
872	n/a	if (fparg_count != 0)
873	n/a	flags \|= FLAG_FP_ARGUMENTS;
874	n/a
875	n/a	#if defined(POWERPC_DARWIN64)
876	n/a	/* Space to image the FPR registers, if needed - which includes when they might be
877	n/a	used in a struct return. */
878	n/a	if (fparg_count != 0
879	n/a	\|\| ((flags & FLAG_RETURNS_STRUCT)
880	n/a	&& (flags & FLAG_RETURNS_FP)))
881	n/a	bytes += NUM_FPR_ARG_REGISTERS * sizeof(double);
882	n/a	#else
883	n/a	/* Space for the FPR registers, if needed. */
884	n/a	if (fparg_count != 0)
885	n/a	bytes += NUM_FPR_ARG_REGISTERS * sizeof(double);
886	n/a	#endif
887	n/a
888	n/a	/* Stack space. */
889	n/a	#ifdef POWERPC64
890	n/a	if ((intarg_count + fparg_count) > NUM_GPR_ARG_REGISTERS)
891	n/a	bytes += (intarg_count + fparg_count) * sizeof(long);
892	n/a	#else
893	n/a	if ((intarg_count + 2 * fparg_count) > NUM_GPR_ARG_REGISTERS)
894	n/a	bytes += (intarg_count + 2 * fparg_count) * sizeof(long);
895	n/a	#endif
896	n/a	else
897	n/a	bytes += NUM_GPR_ARG_REGISTERS * sizeof(long);
898	n/a
899	n/a	/* The stack space allocated needs to be a multiple of 16 bytes. */
900	n/a	bytes = ALIGN(bytes, 16) ;
901	n/a
902	n/a	cif->flags = flags;
903	n/a	cif->bytes = bytes;
904	n/a
905	n/a	return FFI_OK;
906	n/a	}
907	n/a
908	n/a	extern void ffi_call_AIX(extended_cif , long, unsigned, unsigned ,
909	n/a	void (fn)(void), void (fn2)(void));
910	n/a
911	n/a	extern void ffi_call_DARWIN(extended_cif , long, unsigned, unsigned ,
912	n/a	void (fn)(void), void (fn2)(void), ffi_type*);
913	n/a
914	n/a	void
915	n/a	ffi_call (ffi_cif cif, void (fn)(void), void rvalue, void *avalue)
916	n/a	{
917	n/a	extended_cif ecif;
918	n/a
919	n/a	ecif.cif = cif;
920	n/a	ecif.avalue = avalue;
921	n/a
922	n/a	/* If the return value is a struct and we don't have a return
923	n/a	value address then we need to make one. */
924	n/a
925	n/a	if ((rvalue == NULL) &&
926	n/a	(cif->rtype->type == FFI_TYPE_STRUCT))
927	n/a	{
928	n/a	ecif.rvalue = alloca (cif->rtype->size);
929	n/a	}
930	n/a	else
931	n/a	ecif.rvalue = rvalue;
932	n/a
933	n/a	switch (cif->abi)
934	n/a	{
935	n/a	case FFI_AIX:
936	n/a	ffi_call_AIX(&ecif, -(long)cif->bytes, cif->flags, ecif.rvalue, fn,
937	n/a	FFI_FN(ffi_prep_args));
938	n/a	break;
939	n/a	case FFI_DARWIN:
940	n/a	ffi_call_DARWIN(&ecif, -(long)cif->bytes, cif->flags, ecif.rvalue, fn,
941	n/a	FFI_FN(ffi_prep_args), cif->rtype);
942	n/a	break;
943	n/a	default:
944	n/a	FFI_ASSERT(0);
945	n/a	break;
946	n/a	}
947	n/a	}
948	n/a
949	n/a	static void flush_icache(char *);
950	n/a	static void flush_range(char *, int);
951	n/a
952	n/a	/* The layout of a function descriptor. A C function pointer really
953	n/a	points to one of these. */
954	n/a
955	n/a	typedef struct aix_fd_struct {
956	n/a	void *code_pointer;
957	n/a	void *toc;
958	n/a	} aix_fd;
959	n/a
960	n/a	/* here I'd like to add the stack frame layout we use in darwin_closure.S
961	n/a	and aix_closure.S
962	n/a
963	n/a	m32/m64
964	n/a
965	n/a	The stack layout looks like this:
966	n/a
967	n/a	\| Additional params... \| \| Higher address
968	n/a	~ ~ ~
969	n/a	\| Parameters (at least 8*4/8=32/64) \| \| NUM_GPR_ARG_REGISTERS
970	n/a	\|--------------------------------------------\| \|
971	n/a	\| TOC=R2 (AIX) Reserved (Darwin) 4/8 \| \|
972	n/a	\|--------------------------------------------\| \|
973	n/a	\| Reserved 2*4/8 \| \|
974	n/a	\|--------------------------------------------\| \|
975	n/a	\| Space for callee's LR 4/8 \| \|
976	n/a	\|--------------------------------------------\| \|
977	n/a	\| Saved CR [low word for m64] 4/8 \| \|
978	n/a	\|--------------------------------------------\| \|
979	n/a	\| Current backchain pointer 4/8 \|-/ Parent's frame.
980	n/a	\|--------------------------------------------\| <+ <<< on entry to ffi_closure_ASM
981	n/a	\| Result Bytes 16 \| \|
982	n/a	\|--------------------------------------------\| \|
983	n/a	~ padding to 16-byte alignment ~ ~
984	n/a	\|--------------------------------------------\| \|
985	n/a	\| NUM_FPR_ARG_REGISTERS slots \| \|
986	n/a	\| here fp13 .. fp1 13*8 \| \|
987	n/a	\|--------------------------------------------\| \|
988	n/a	\| R3..R10 8*4/8=32/64 \| \| NUM_GPR_ARG_REGISTERS
989	n/a	\|--------------------------------------------\| \|
990	n/a	\| TOC=R2 (AIX) Reserved (Darwin) 4/8 \| \|
991	n/a	\|--------------------------------------------\| \| stack \|
992	n/a	\| Reserved [compiler,binder] 2*4/8 \| \| grows \|
993	n/a	\|--------------------------------------------\| \| down V
994	n/a	\| Space for callee's LR 4/8 \| \|
995	n/a	\|--------------------------------------------\| \| lower addresses
996	n/a	\| Saved CR [low word for m64] 4/8 \| \|
997	n/a	\|--------------------------------------------\| \| stack pointer here
998	n/a	\| Current backchain pointer 4/8 \|-/ during
999	n/a	\|--------------------------------------------\| <<< ffi_closure_ASM.
1000	n/a
1001	n/a	*/
1002	n/a
1003	n/a	ffi_status
1004	n/a	ffi_prep_closure_loc (ffi_closure* closure,
1005	n/a	ffi_cif* cif,
1006	n/a	void (fun)(ffi_cif, void, void, void),
1007	n/a	void *user_data,
1008	n/a	void *codeloc)
1009	n/a	{
1010	n/a	unsigned int *tramp;
1011	n/a	struct ffi_aix_trampoline_struct *tramp_aix;
1012	n/a	aix_fd *fd;
1013	n/a
1014	n/a	switch (cif->abi)
1015	n/a	{
1016	n/a	case FFI_DARWIN:
1017	n/a
1018	n/a	FFI_ASSERT (cif->abi == FFI_DARWIN);
1019	n/a
1020	n/a	tramp = (unsigned int *) &closure->tramp[0];
1021	n/a	#if defined(POWERPC_DARWIN64)
1022	n/a	tramp[0] = 0x7c0802a6; /* mflr r0 */
1023	n/a	tramp[1] = 0x429f0015; /* bcl- 20,4cr7+so, +0x18 (L1) /
1024	n/a	/* We put the addresses here. */
1025	n/a	tramp[6] = 0x7d6802a6; /L1: mflr r11 /
1026	n/a	tramp[7] = 0xe98b0000; /* ld r12,0(r11) function address */
1027	n/a	tramp[8] = 0x7c0803a6; /* mtlr r0 */
1028	n/a	tramp[9] = 0x7d8903a6; /* mtctr r12 */
1029	n/a	tramp[10] = 0xe96b0008; /* lwz r11,8(r11) static chain */
1030	n/a	tramp[11] = 0x4e800420; /* bctr */
1031	n/a
1032	n/a	((unsigned long )&tramp[2]) = (unsigned long) ffi_closure_ASM; /* function */
1033	n/a	((unsigned long )&tramp[4]) = (unsigned long) codeloc; /* context */
1034	n/a	#else
1035	n/a	tramp[0] = 0x7c0802a6; /* mflr r0 */
1036	n/a	tramp[1] = 0x429f000d; /* bcl- 20,4cr7+so,0x10 /
1037	n/a	tramp[4] = 0x7d6802a6; /* mflr r11 */
1038	n/a	tramp[5] = 0x818b0000; /* lwz r12,0(r11) function address */
1039	n/a	tramp[6] = 0x7c0803a6; /* mtlr r0 */
1040	n/a	tramp[7] = 0x7d8903a6; /* mtctr r12 */
1041	n/a	tramp[8] = 0x816b0004; /* lwz r11,4(r11) static chain */
1042	n/a	tramp[9] = 0x4e800420; /* bctr */
1043	n/a	tramp[2] = (unsigned long) ffi_closure_ASM; /* function */
1044	n/a	tramp[3] = (unsigned long) codeloc; /* context */
1045	n/a	#endif
1046	n/a	closure->cif = cif;
1047	n/a	closure->fun = fun;
1048	n/a	closure->user_data = user_data;
1049	n/a
1050	n/a	/* Flush the icache. Only necessary on Darwin. */
1051	n/a	flush_range(codeloc, FFI_TRAMPOLINE_SIZE);
1052	n/a
1053	n/a	break;
1054	n/a
1055	n/a	case FFI_AIX:
1056	n/a
1057	n/a	tramp_aix = (struct ffi_aix_trampoline_struct *) (closure->tramp);
1058	n/a	fd = (aix_fd )(void )ffi_closure_ASM;
1059	n/a
1060	n/a	FFI_ASSERT (cif->abi == FFI_AIX);
1061	n/a
1062	n/a	tramp_aix->code_pointer = fd->code_pointer;
1063	n/a	tramp_aix->toc = fd->toc;
1064	n/a	tramp_aix->static_chain = codeloc;
1065	n/a	closure->cif = cif;
1066	n/a	closure->fun = fun;
1067	n/a	closure->user_data = user_data;
1068	n/a	break;
1069	n/a
1070	n/a	default:
1071	n/a	return FFI_BAD_ABI;
1072	n/a	break;
1073	n/a	}
1074	n/a	return FFI_OK;
1075	n/a	}
1076	n/a
1077	n/a	static void
1078	n/a	flush_icache(char *addr)
1079	n/a	{
1080	n/a	#ifndef _AIX
1081	n/a	__asm__ volatile (
1082	n/a	"dcbf 0,%0\n"
1083	n/a	"\tsync\n"
1084	n/a	"\ticbi 0,%0\n"
1085	n/a	"\tsync\n"
1086	n/a	"\tisync"
1087	n/a	: : "r"(addr) : "memory");
1088	n/a	#endif
1089	n/a	}
1090	n/a
1091	n/a	static void
1092	n/a	flush_range(char * addr1, int size)
1093	n/a	{
1094	n/a	#define MIN_LINE_SIZE 32
1095	n/a	int i;
1096	n/a	for (i = 0; i < size; i += MIN_LINE_SIZE)
1097	n/a	flush_icache(addr1+i);
1098	n/a	flush_icache(addr1+size-1);
1099	n/a	}
1100	n/a
1101	n/a	typedef union
1102	n/a	{
1103	n/a	float f;
1104	n/a	double d;
1105	n/a	} ffi_dblfl;
1106	n/a
1107	n/a	ffi_type *
1108	n/a	ffi_closure_helper_DARWIN (ffi_closure , void ,
1109	n/a	unsigned long , ffi_dblfl );
1110	n/a
1111	n/a	/* Basically the trampoline invokes ffi_closure_ASM, and on
1112	n/a	entry, r11 holds the address of the closure.
1113	n/a	After storing the registers that could possibly contain
1114	n/a	parameters to be passed into the stack frame and setting
1115	n/a	up space for a return value, ffi_closure_ASM invokes the
1116	n/a	following helper function to do most of the work. */
1117	n/a
1118	n/a	ffi_type *
1119	n/a	ffi_closure_helper_DARWIN (ffi_closure closure, void rvalue,
1120	n/a	unsigned long pgr, ffi_dblfl pfr)
1121	n/a	{
1122	n/a	/* rvalue is the pointer to space for return value in closure assembly
1123	n/a	pgr is the pointer to where r3-r10 are stored in ffi_closure_ASM
1124	n/a	pfr is the pointer to where f1-f13 are stored in ffi_closure_ASM. */
1125	n/a
1126	n/a	typedef double ldbits[2];
1127	n/a
1128	n/a	union ldu
1129	n/a	{
1130	n/a	ldbits lb;
1131	n/a	long double ld;
1132	n/a	};
1133	n/a
1134	n/a	void ** avalue;
1135	n/a	ffi_type ** arg_types;
1136	n/a	long i, avn;
1137	n/a	ffi_cif * cif;
1138	n/a	ffi_dblfl * end_pfr = pfr + NUM_FPR_ARG_REGISTERS;
1139	n/a	unsigned size_al;
1140	n/a	#if defined(POWERPC_DARWIN64)
1141	n/a	unsigned fpsused = 0;
1142	n/a	#endif
1143	n/a
1144	n/a	cif = closure->cif;
1145	n/a	avalue = alloca (cif->nargs * sizeof(void *));
1146	n/a
1147	n/a	if (cif->rtype->type == FFI_TYPE_STRUCT)
1148	n/a	{
1149	n/a	#if defined(POWERPC_DARWIN64)
1150	n/a	if (!darwin64_struct_ret_by_value_p (cif->rtype))
1151	n/a	{
1152	n/a	/* Won't fit into the regs - return by ref. */
1153	n/a	rvalue = (void ) pgr;
1154	n/a	pgr++;
1155	n/a	}
1156	n/a	#elif defined(DARWIN_PPC)
1157	n/a	if (cif->rtype->size > 4)
1158	n/a	{
1159	n/a	rvalue = (void ) pgr;
1160	n/a	pgr++;
1161	n/a	}
1162	n/a	#else /* assume we return by ref. */
1163	n/a	rvalue = (void ) pgr;
1164	n/a	pgr++;
1165	n/a	#endif
1166	n/a	}
1167	n/a
1168	n/a	i = 0;
1169	n/a	avn = cif->nargs;
1170	n/a	arg_types = cif->arg_types;
1171	n/a
1172	n/a	/* Grab the addresses of the arguments from the stack frame. */
1173	n/a	while (i < avn)
1174	n/a	{
1175	n/a	switch (arg_types[i]->type)
1176	n/a	{
1177	n/a	case FFI_TYPE_SINT8:
1178	n/a	case FFI_TYPE_UINT8:
1179	n/a	#if defined(POWERPC64)
1180	n/a	avalue[i] = (char *) pgr + 7;
1181	n/a	#else
1182	n/a	avalue[i] = (char *) pgr + 3;
1183	n/a	#endif
1184	n/a	pgr++;
1185	n/a	break;
1186	n/a
1187	n/a	case FFI_TYPE_SINT16:
1188	n/a	case FFI_TYPE_UINT16:
1189	n/a	#if defined(POWERPC64)
1190	n/a	avalue[i] = (char *) pgr + 6;
1191	n/a	#else
1192	n/a	avalue[i] = (char *) pgr + 2;
1193	n/a	#endif
1194	n/a	pgr++;
1195	n/a	break;
1196	n/a
1197	n/a	case FFI_TYPE_SINT32:
1198	n/a	case FFI_TYPE_UINT32:
1199	n/a	#if defined(POWERPC64)
1200	n/a	avalue[i] = (char *) pgr + 4;
1201	n/a	#else
1202	n/a	case FFI_TYPE_POINTER:
1203	n/a	avalue[i] = pgr;
1204	n/a	#endif
1205	n/a	pgr++;
1206	n/a	break;
1207	n/a
1208	n/a	case FFI_TYPE_STRUCT:
1209	n/a	size_al = arg_types[i]->size;
1210	n/a	#if defined(POWERPC_DARWIN64)
1211	n/a	pgr = (unsigned long )ALIGN((char )pgr, arg_types[i]->alignment);
1212	n/a	if (size_al < 3 \|\| size_al == 4)
1213	n/a	{
1214	n/a	avalue[i] = ((char *)pgr)+8-size_al;
1215	n/a	if (arg_types[i]->elements[0]->type == FFI_TYPE_FLOAT
1216	n/a	&& fpsused < NUM_FPR_ARG_REGISTERS)
1217	n/a	{
1218	n/a	(float )pgr = (float) (double )pfr;
1219	n/a	pfr++;
1220	n/a	fpsused++;
1221	n/a	}
1222	n/a	}
1223	n/a	else
1224	n/a	{
1225	n/a	if (size_al != 16)
1226	n/a	pfr = (ffi_dblfl *)
1227	n/a	darwin64_struct_floats_to_mem (arg_types[i], (char *)pgr,
1228	n/a	(double *)pfr, &fpsused);
1229	n/a	avalue[i] = pgr;
1230	n/a	}
1231	n/a	pgr += (size_al + 7) / 8;
1232	n/a	#else
1233	n/a	/* If the first member of the struct is a double, then align
1234	n/a	the struct to double-word. */
1235	n/a	if (arg_types[i]->elements[0]->type == FFI_TYPE_DOUBLE)
1236	n/a	size_al = ALIGN(arg_types[i]->size, 8);
1237	n/a	# if defined(POWERPC64)
1238	n/a	FFI_ASSERT (cif->abi != FFI_DARWIN);
1239	n/a	avalue[i] = pgr;
1240	n/a	pgr += (size_al + 7) / 8;
1241	n/a	# else
1242	n/a	/* Structures that match the basic modes (QI 1 byte, HI 2 bytes,
1243	n/a	SI 4 bytes) are aligned as if they were those modes. */
1244	n/a	if (size_al < 3 && cif->abi == FFI_DARWIN)
1245	n/a	avalue[i] = (char*) pgr + 4 - size_al;
1246	n/a	else
1247	n/a	avalue[i] = pgr;
1248	n/a	pgr += (size_al + 3) / 4;
1249	n/a	# endif
1250	n/a	#endif
1251	n/a	break;
1252	n/a
1253	n/a	case FFI_TYPE_SINT64:
1254	n/a	case FFI_TYPE_UINT64:
1255	n/a	#if defined(POWERPC64)
1256	n/a	case FFI_TYPE_POINTER:
1257	n/a	avalue[i] = pgr;
1258	n/a	pgr++;
1259	n/a	break;
1260	n/a	#else
1261	n/a	/* Long long ints are passed in two gpr's. */
1262	n/a	avalue[i] = pgr;
1263	n/a	pgr += 2;
1264	n/a	break;
1265	n/a	#endif
1266	n/a
1267	n/a	case FFI_TYPE_FLOAT:
1268	n/a	/* A float value consumes a GPR.
1269	n/a	There are 13 64bit floating point registers. */
1270	n/a	if (pfr < end_pfr)
1271	n/a	{
1272	n/a	double temp = pfr->d;
1273	n/a	pfr->f = (float) temp;
1274	n/a	avalue[i] = pfr;
1275	n/a	pfr++;
1276	n/a	}
1277	n/a	else
1278	n/a	{
1279	n/a	avalue[i] = pgr;
1280	n/a	}
1281	n/a	pgr++;
1282	n/a	break;
1283	n/a
1284	n/a	case FFI_TYPE_DOUBLE:
1285	n/a	/* A double value consumes two GPRs.
1286	n/a	There are 13 64bit floating point registers. */
1287	n/a	if (pfr < end_pfr)
1288	n/a	{
1289	n/a	avalue[i] = pfr;
1290	n/a	pfr++;
1291	n/a	}
1292	n/a	else
1293	n/a	{
1294	n/a	avalue[i] = pgr;
1295	n/a	}
1296	n/a	#ifdef POWERPC64
1297	n/a	pgr++;
1298	n/a	#else
1299	n/a	pgr += 2;
1300	n/a	#endif
1301	n/a	break;
1302	n/a
1303	n/a	#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
1304	n/a
1305	n/a	case FFI_TYPE_LONGDOUBLE:
1306	n/a	#ifdef POWERPC64
1307	n/a	if (pfr + 1 < end_pfr)
1308	n/a	{
1309	n/a	avalue[i] = pfr;
1310	n/a	pfr += 2;
1311	n/a	}
1312	n/a	else
1313	n/a	{
1314	n/a	if (pfr < end_pfr)
1315	n/a	{
1316	n/a	pgr = (unsigned long *) pfr;
1317	n/a	pfr++;
1318	n/a	}
1319	n/a	avalue[i] = pgr;
1320	n/a	}
1321	n/a	pgr += 2;
1322	n/a	#else /* POWERPC64 */
1323	n/a	/* A long double value consumes four GPRs and two FPRs.
1324	n/a	There are 13 64bit floating point registers. */
1325	n/a	if (pfr + 1 < end_pfr)
1326	n/a	{
1327	n/a	avalue[i] = pfr;
1328	n/a	pfr += 2;
1329	n/a	}
1330	n/a	/* Here we have the situation where one part of the long double
1331	n/a	is stored in fpr13 and the other part is already on the stack.
1332	n/a	We use a union to pass the long double to avalue[i]. */
1333	n/a	else if (pfr + 1 == end_pfr)
1334	n/a	{
1335	n/a	union ldu temp_ld;
1336	n/a	memcpy (&temp_ld.lb[0], pfr, sizeof(ldbits));
1337	n/a	memcpy (&temp_ld.lb[1], pgr + 2, sizeof(ldbits));
1338	n/a	avalue[i] = &temp_ld.ld;
1339	n/a	pfr++;
1340	n/a	}
1341	n/a	else
1342	n/a	{
1343	n/a	avalue[i] = pgr;
1344	n/a	}
1345	n/a	pgr += 4;
1346	n/a	#endif /* POWERPC64 */
1347	n/a	break;
1348	n/a	#endif
1349	n/a	default:
1350	n/a	FFI_ASSERT(0);
1351	n/a	}
1352	n/a	i++;
1353	n/a	}
1354	n/a
1355	n/a	(closure->fun) (cif, rvalue, avalue, closure->user_data);
1356	n/a
1357	n/a	/* Tell ffi_closure_ASM to perform return type promotions. */
1358	n/a	return cif->rtype;
1359	n/a	}