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

#	count	content
1	n/a	/* -----------------------------------------------------------------------
2	n/a	ffi.c - Copyright (c) 1998, 2007, 2008, 2012 Red Hat, Inc.
3	n/a	Copyright (c) 2000 Hewlett Packard Company
4	n/a	Copyright (c) 2011 Anthony Green
5	n/a
6	n/a	IA64 Foreign Function Interface
7	n/a
8	n/a	Permission is hereby granted, free of charge, to any person obtaining
9	n/a	a copy of this software and associated documentation files (the
10	n/a	``Software''), to deal in the Software without restriction, including
11	n/a	without limitation the rights to use, copy, modify, merge, publish,
12	n/a	distribute, sublicense, and/or sell copies of the Software, and to
13	n/a	permit persons to whom the Software is furnished to do so, subject to
14	n/a	the following conditions:
15	n/a
16	n/a	The above copyright notice and this permission notice shall be included
17	n/a	in all copies or substantial portions of the Software.
18	n/a
19	n/a	THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
20	n/a	EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
21	n/a	MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
22	n/a	NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
23	n/a	HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
24	n/a	WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
25	n/a	OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
26	n/a	DEALINGS IN THE SOFTWARE.
27	n/a	----------------------------------------------------------------------- */
28	n/a
29	n/a	#include <ffi.h>
30	n/a	#include <ffi_common.h>
31	n/a
32	n/a	#include <stdlib.h>
33	n/a	#include <stdbool.h>
34	n/a	#include <float.h>
35	n/a
36	n/a	#include "ia64_flags.h"
37	n/a
38	n/a	/* A 64-bit pointer value. In LP64 mode, this is effectively a plain
39	n/a	pointer. In ILP32 mode, it's a pointer that's been extended to
40	n/a	64 bits by "addp4". */
41	n/a	typedef void *PTR64 __attribute__((mode(DI)));
42	n/a
43	n/a	/* Memory image of fp register contents. This is the implementation
44	n/a	specific format used by ldf.fill/stf.spill. All we care about is
45	n/a	that it wants a 16 byte aligned slot. */
46	n/a	typedef struct
47	n/a	{
48	n/a	UINT64 x[2] __attribute__((aligned(16)));
49	n/a	} fpreg;
50	n/a
51	n/a
52	n/a	/* The stack layout given to ffi_call_unix and ffi_closure_unix_inner. */
53	n/a
54	n/a	struct ia64_args
55	n/a	{
56	n/a	fpreg fp_regs[8]; /* Contents of 8 fp arg registers. */
57	n/a	UINT64 gp_regs[8]; /* Contents of 8 gp arg registers. */
58	n/a	UINT64 other_args[]; /* Arguments passed on stack, variable size. */
59	n/a	};
60	n/a
61	n/a
62	n/a	/* Adjust ADDR, a pointer to an 8 byte slot, to point to the low LEN bytes. */
63	n/a
64	n/a	static inline void *
65	n/a	endian_adjust (void *addr, size_t len)
66	n/a	{
67	n/a	#ifdef __BIG_ENDIAN__
68	n/a	return addr + (8 - len);
69	n/a	#else
70	n/a	return addr;
71	n/a	#endif
72	n/a	}
73	n/a
74	n/a	/* Store VALUE to ADDR in the current cpu implementation's fp spill format.
75	n/a	This is a macro instead of a function, so that it works for all 3 floating
76	n/a	point types without type conversions. Type conversion to long double breaks
77	n/a	the denorm support. */
78	n/a
79	n/a	#define stf_spill(addr, value) \
80	n/a	asm ("stf.spill %0 = %1%P0" : "=m" (*addr) : "f"(value));
81	n/a
82	n/a	/* Load a value from ADDR, which is in the current cpu implementation's
83	n/a	fp spill format. As above, this must also be a macro. */
84	n/a
85	n/a	#define ldf_fill(result, addr) \
86	n/a	asm ("ldf.fill %0 = %1%P1" : "=f"(result) : "m"(*addr));
87	n/a
88	n/a	/* Return the size of the C type associated with with TYPE. Which will
89	n/a	be one of the FFI_IA64_TYPE_HFA_* values. */
90	n/a
91	n/a	static size_t
92	n/a	hfa_type_size (int type)
93	n/a	{
94	n/a	switch (type)
95	n/a	{
96	n/a	case FFI_IA64_TYPE_HFA_FLOAT:
97	n/a	return sizeof(float);
98	n/a	case FFI_IA64_TYPE_HFA_DOUBLE:
99	n/a	return sizeof(double);
100	n/a	case FFI_IA64_TYPE_HFA_LDOUBLE:
101	n/a	return sizeof(__float80);
102	n/a	default:
103	n/a	abort ();
104	n/a	}
105	n/a	}
106	n/a
107	n/a	/* Load from ADDR a value indicated by TYPE. Which will be one of
108	n/a	the FFI_IA64_TYPE_HFA_* values. */
109	n/a
110	n/a	static void
111	n/a	hfa_type_load (fpreg fpaddr, int type, void addr)
112	n/a	{
113	n/a	switch (type)
114	n/a	{
115	n/a	case FFI_IA64_TYPE_HFA_FLOAT:
116	n/a	stf_spill (fpaddr, (float ) addr);
117	n/a	return;
118	n/a	case FFI_IA64_TYPE_HFA_DOUBLE:
119	n/a	stf_spill (fpaddr, (double ) addr);
120	n/a	return;
121	n/a	case FFI_IA64_TYPE_HFA_LDOUBLE:
122	n/a	stf_spill (fpaddr, (__float80 ) addr);
123	n/a	return;
124	n/a	default:
125	n/a	abort ();
126	n/a	}
127	n/a	}
128	n/a
129	n/a	/* Load VALUE into ADDR as indicated by TYPE. Which will be one of
130	n/a	the FFI_IA64_TYPE_HFA_* values. */
131	n/a
132	n/a	static void
133	n/a	hfa_type_store (int type, void addr, fpreg fpaddr)
134	n/a	{
135	n/a	switch (type)
136	n/a	{
137	n/a	case FFI_IA64_TYPE_HFA_FLOAT:
138	n/a	{
139	n/a	float result;
140	n/a	ldf_fill (result, fpaddr);
141	n/a	(float ) addr = result;
142	n/a	break;
143	n/a	}
144	n/a	case FFI_IA64_TYPE_HFA_DOUBLE:
145	n/a	{
146	n/a	double result;
147	n/a	ldf_fill (result, fpaddr);
148	n/a	(double ) addr = result;
149	n/a	break;
150	n/a	}
151	n/a	case FFI_IA64_TYPE_HFA_LDOUBLE:
152	n/a	{
153	n/a	__float80 result;
154	n/a	ldf_fill (result, fpaddr);
155	n/a	(__float80 ) addr = result;
156	n/a	break;
157	n/a	}
158	n/a	default:
159	n/a	abort ();
160	n/a	}
161	n/a	}
162	n/a
163	n/a	/* Is TYPE a struct containing floats, doubles, or extended doubles,
164	n/a	all of the same fp type? If so, return the element type. Return
165	n/a	FFI_TYPE_VOID if not. */
166	n/a
167	n/a	static int
168	n/a	hfa_element_type (ffi_type *type, int nested)
169	n/a	{
170	n/a	int element = FFI_TYPE_VOID;
171	n/a
172	n/a	switch (type->type)
173	n/a	{
174	n/a	case FFI_TYPE_FLOAT:
175	n/a	/* We want to return VOID for raw floating-point types, but the
176	n/a	synthetic HFA type if we're nested within an aggregate. */
177	n/a	if (nested)
178	n/a	element = FFI_IA64_TYPE_HFA_FLOAT;
179	n/a	break;
180	n/a
181	n/a	case FFI_TYPE_DOUBLE:
182	n/a	/* Similarly. */
183	n/a	if (nested)
184	n/a	element = FFI_IA64_TYPE_HFA_DOUBLE;
185	n/a	break;
186	n/a
187	n/a	case FFI_TYPE_LONGDOUBLE:
188	n/a	/* Similarly, except that that HFA is true for double extended,
189	n/a	but not quad precision. Both have sizeof == 16, so tell the
190	n/a	difference based on the precision. */
191	n/a	if (LDBL_MANT_DIG == 64 && nested)
192	n/a	element = FFI_IA64_TYPE_HFA_LDOUBLE;
193	n/a	break;
194	n/a
195	n/a	case FFI_TYPE_STRUCT:
196	n/a	{
197	n/a	ffi_type **ptr = &type->elements[0];
198	n/a
199	n/a	for (ptr = &type->elements[0]; *ptr ; ptr++)
200	n/a	{
201	n/a	int sub_element = hfa_element_type (*ptr, 1);
202	n/a	if (sub_element == FFI_TYPE_VOID)
203	n/a	return FFI_TYPE_VOID;
204	n/a
205	n/a	if (element == FFI_TYPE_VOID)
206	n/a	element = sub_element;
207	n/a	else if (element != sub_element)
208	n/a	return FFI_TYPE_VOID;
209	n/a	}
210	n/a	}
211	n/a	break;
212	n/a
213	n/a	default:
214	n/a	return FFI_TYPE_VOID;
215	n/a	}
216	n/a
217	n/a	return element;
218	n/a	}
219	n/a
220	n/a
221	n/a	/* Perform machine dependent cif processing. */
222	n/a
223	n/a	ffi_status
224	n/a	ffi_prep_cif_machdep(ffi_cif *cif)
225	n/a	{
226	n/a	int flags;
227	n/a
228	n/a	/* Adjust cif->bytes to include space for the bits of the ia64_args frame
229	n/a	that precedes the integer register portion. The estimate that the
230	n/a	generic bits did for the argument space required is good enough for the
231	n/a	integer component. */
232	n/a	cif->bytes += offsetof(struct ia64_args, gp_regs[0]);
233	n/a	if (cif->bytes < sizeof(struct ia64_args))
234	n/a	cif->bytes = sizeof(struct ia64_args);
235	n/a
236	n/a	/* Set the return type flag. */
237	n/a	flags = cif->rtype->type;
238	n/a	switch (cif->rtype->type)
239	n/a	{
240	n/a	case FFI_TYPE_LONGDOUBLE:
241	n/a	/* Leave FFI_TYPE_LONGDOUBLE as meaning double extended precision,
242	n/a	and encode quad precision as a two-word integer structure. */
243	n/a	if (LDBL_MANT_DIG != 64)
244	n/a	flags = FFI_IA64_TYPE_SMALL_STRUCT \| (16 << 8);
245	n/a	break;
246	n/a
247	n/a	case FFI_TYPE_STRUCT:
248	n/a	{
249	n/a	size_t size = cif->rtype->size;
250	n/a	int hfa_type = hfa_element_type (cif->rtype, 0);
251	n/a
252	n/a	if (hfa_type != FFI_TYPE_VOID)
253	n/a	{
254	n/a	size_t nelts = size / hfa_type_size (hfa_type);
255	n/a	if (nelts <= 8)
256	n/a	flags = hfa_type \| (size << 8);
257	n/a	}
258	n/a	else
259	n/a	{
260	n/a	if (size <= 32)
261	n/a	flags = FFI_IA64_TYPE_SMALL_STRUCT \| (size << 8);
262	n/a	}
263	n/a	}
264	n/a	break;
265	n/a
266	n/a	default:
267	n/a	break;
268	n/a	}
269	n/a	cif->flags = flags;
270	n/a
271	n/a	return FFI_OK;
272	n/a	}
273	n/a
274	n/a	extern int ffi_call_unix (struct ia64_args , PTR64, void ()(void), UINT64);
275	n/a
276	n/a	void
277	n/a	ffi_call(ffi_cif cif, void (fn)(void), void rvalue, void *avalue)
278	n/a	{
279	n/a	struct ia64_args *stack;
280	n/a	long i, avn, gpcount, fpcount;
281	n/a	ffi_type **p_arg;
282	n/a
283	n/a	FFI_ASSERT (cif->abi == FFI_UNIX);
284	n/a
285	n/a	/* If we have no spot for a return value, make one. */
286	n/a	if (rvalue == NULL && cif->rtype->type != FFI_TYPE_VOID)
287	n/a	rvalue = alloca (cif->rtype->size);
288	n/a
289	n/a	/* Allocate the stack frame. */
290	n/a	stack = alloca (cif->bytes);
291	n/a
292	n/a	gpcount = fpcount = 0;
293	n/a	avn = cif->nargs;
294	n/a	for (i = 0, p_arg = cif->arg_types; i < avn; i++, p_arg++)
295	n/a	{
296	n/a	switch ((*p_arg)->type)
297	n/a	{
298	n/a	case FFI_TYPE_SINT8:
299	n/a	stack->gp_regs[gpcount++] = (SINT8 )avalue[i];
300	n/a	break;
301	n/a	case FFI_TYPE_UINT8:
302	n/a	stack->gp_regs[gpcount++] = (UINT8 )avalue[i];
303	n/a	break;
304	n/a	case FFI_TYPE_SINT16:
305	n/a	stack->gp_regs[gpcount++] = (SINT16 )avalue[i];
306	n/a	break;
307	n/a	case FFI_TYPE_UINT16:
308	n/a	stack->gp_regs[gpcount++] = (UINT16 )avalue[i];
309	n/a	break;
310	n/a	case FFI_TYPE_SINT32:
311	n/a	stack->gp_regs[gpcount++] = (SINT32 )avalue[i];
312	n/a	break;
313	n/a	case FFI_TYPE_UINT32:
314	n/a	stack->gp_regs[gpcount++] = (UINT32 )avalue[i];
315	n/a	break;
316	n/a	case FFI_TYPE_SINT64:
317	n/a	case FFI_TYPE_UINT64:
318	n/a	stack->gp_regs[gpcount++] = (UINT64 )avalue[i];
319	n/a	break;
320	n/a
321	n/a	case FFI_TYPE_POINTER:
322	n/a	stack->gp_regs[gpcount++] = (UINT64)(PTR64) (void *)avalue[i];
323	n/a	break;
324	n/a
325	n/a	case FFI_TYPE_FLOAT:
326	n/a	if (gpcount < 8 && fpcount < 8)
327	n/a	stf_spill (&stack->fp_regs[fpcount++], (float )avalue[i]);
328	n/a	{
329	n/a	UINT32 tmp;
330	n/a	memcpy (&tmp, avalue[i], sizeof (UINT32));
331	n/a	stack->gp_regs[gpcount++] = tmp;
332	n/a	}
333	n/a	break;
334	n/a
335	n/a	case FFI_TYPE_DOUBLE:
336	n/a	if (gpcount < 8 && fpcount < 8)
337	n/a	stf_spill (&stack->fp_regs[fpcount++], (double )avalue[i]);
338	n/a	memcpy (&stack->gp_regs[gpcount++], avalue[i], sizeof (UINT64));
339	n/a	break;
340	n/a
341	n/a	case FFI_TYPE_LONGDOUBLE:
342	n/a	if (gpcount & 1)
343	n/a	gpcount++;
344	n/a	if (LDBL_MANT_DIG == 64 && gpcount < 8 && fpcount < 8)
345	n/a	stf_spill (&stack->fp_regs[fpcount++], (__float80 )avalue[i]);
346	n/a	memcpy (&stack->gp_regs[gpcount], avalue[i], 16);
347	n/a	gpcount += 2;
348	n/a	break;
349	n/a
350	n/a	case FFI_TYPE_STRUCT:
351	n/a	{
352	n/a	size_t size = (*p_arg)->size;
353	n/a	size_t align = (*p_arg)->alignment;
354	n/a	int hfa_type = hfa_element_type (*p_arg, 0);
355	n/a
356	n/a	FFI_ASSERT (align <= 16);
357	n/a	if (align == 16 && (gpcount & 1))
358	n/a	gpcount++;
359	n/a
360	n/a	if (hfa_type != FFI_TYPE_VOID)
361	n/a	{
362	n/a	size_t hfa_size = hfa_type_size (hfa_type);
363	n/a	size_t offset = 0;
364	n/a	size_t gp_offset = gpcount * 8;
365	n/a
366	n/a	while (fpcount < 8
367	n/a	&& offset < size
368	n/a	&& gp_offset < 8 * 8)
369	n/a	{
370	n/a	hfa_type_load (&stack->fp_regs[fpcount], hfa_type,
371	n/a	avalue[i] + offset);
372	n/a	offset += hfa_size;
373	n/a	gp_offset += hfa_size;
374	n/a	fpcount += 1;
375	n/a	}
376	n/a	}
377	n/a
378	n/a	memcpy (&stack->gp_regs[gpcount], avalue[i], size);
379	n/a	gpcount += (size + 7) / 8;
380	n/a	}
381	n/a	break;
382	n/a
383	n/a	default:
384	n/a	abort ();
385	n/a	}
386	n/a	}
387	n/a
388	n/a	ffi_call_unix (stack, rvalue, fn, cif->flags);
389	n/a	}
390	n/a
391	n/a	/* Closures represent a pair consisting of a function pointer, and
392	n/a	some user data. A closure is invoked by reinterpreting the closure
393	n/a	as a function pointer, and branching to it. Thus we can make an
394	n/a	interpreted function callable as a C function: We turn the
395	n/a	interpreter itself, together with a pointer specifying the
396	n/a	interpreted procedure, into a closure.
397	n/a
398	n/a	For IA64, function pointer are already pairs consisting of a code
399	n/a	pointer, and a gp pointer. The latter is needed to access global
400	n/a	variables. Here we set up such a pair as the first two words of
401	n/a	the closure (in the "trampoline" area), but we replace the gp
402	n/a	pointer with a pointer to the closure itself. We also add the real
403	n/a	gp pointer to the closure. This allows the function entry code to
404	n/a	both retrieve the user data, and to restore the correct gp pointer. */
405	n/a
406	n/a	extern void ffi_closure_unix ();
407	n/a
408	n/a	ffi_status
409	n/a	ffi_prep_closure_loc (ffi_closure* closure,
410	n/a	ffi_cif* cif,
411	n/a	void (fun)(ffi_cif,void,void,void),
412	n/a	void *user_data,
413	n/a	void *codeloc)
414	n/a	{
415	n/a	/* The layout of a function descriptor. A C function pointer really
416	n/a	points to one of these. */
417	n/a	struct ia64_fd
418	n/a	{
419	n/a	UINT64 code_pointer;
420	n/a	UINT64 gp;
421	n/a	};
422	n/a
423	n/a	struct ffi_ia64_trampoline_struct
424	n/a	{
425	n/a	UINT64 code_pointer; /* Pointer to ffi_closure_unix. */
426	n/a	UINT64 fake_gp; /* Pointer to closure, installed as gp. */
427	n/a	UINT64 real_gp; /* Real gp value. */
428	n/a	};
429	n/a
430	n/a	struct ffi_ia64_trampoline_struct *tramp;
431	n/a	struct ia64_fd *fd;
432	n/a
433	n/a	if (cif->abi != FFI_UNIX)
434	n/a	return FFI_BAD_ABI;
435	n/a
436	n/a	tramp = (struct ffi_ia64_trampoline_struct *)closure->tramp;
437	n/a	fd = (struct ia64_fd )(void )ffi_closure_unix;
438	n/a
439	n/a	tramp->code_pointer = fd->code_pointer;
440	n/a	tramp->real_gp = fd->gp;
441	n/a	tramp->fake_gp = (UINT64)(PTR64)codeloc;
442	n/a	closure->cif = cif;
443	n/a	closure->user_data = user_data;
444	n/a	closure->fun = fun;
445	n/a
446	n/a	return FFI_OK;
447	n/a	}
448	n/a
449	n/a
450	n/a	UINT64
451	n/a	ffi_closure_unix_inner (ffi_closure closure, struct ia64_args stack,
452	n/a	void rvalue, void r8)
453	n/a	{
454	n/a	ffi_cif *cif;
455	n/a	void **avalue;
456	n/a	ffi_type **p_arg;
457	n/a	long i, avn, gpcount, fpcount;
458	n/a
459	n/a	cif = closure->cif;
460	n/a	avn = cif->nargs;
461	n/a	avalue = alloca (avn * sizeof (void *));
462	n/a
463	n/a	/* If the structure return value is passed in memory get that location
464	n/a	from r8 so as to pass the value directly back to the caller. */
465	n/a	if (cif->flags == FFI_TYPE_STRUCT)
466	n/a	rvalue = r8;
467	n/a
468	n/a	gpcount = fpcount = 0;
469	n/a	for (i = 0, p_arg = cif->arg_types; i < avn; i++, p_arg++)
470	n/a	{
471	n/a	switch ((*p_arg)->type)
472	n/a	{
473	n/a	case FFI_TYPE_SINT8:
474	n/a	case FFI_TYPE_UINT8:
475	n/a	avalue[i] = endian_adjust(&stack->gp_regs[gpcount++], 1);
476	n/a	break;
477	n/a	case FFI_TYPE_SINT16:
478	n/a	case FFI_TYPE_UINT16:
479	n/a	avalue[i] = endian_adjust(&stack->gp_regs[gpcount++], 2);
480	n/a	break;
481	n/a	case FFI_TYPE_SINT32:
482	n/a	case FFI_TYPE_UINT32:
483	n/a	avalue[i] = endian_adjust(&stack->gp_regs[gpcount++], 4);
484	n/a	break;
485	n/a	case FFI_TYPE_SINT64:
486	n/a	case FFI_TYPE_UINT64:
487	n/a	avalue[i] = &stack->gp_regs[gpcount++];
488	n/a	break;
489	n/a	case FFI_TYPE_POINTER:
490	n/a	avalue[i] = endian_adjust(&stack->gp_regs[gpcount++], sizeof(void*));
491	n/a	break;
492	n/a
493	n/a	case FFI_TYPE_FLOAT:
494	n/a	if (gpcount < 8 && fpcount < 8)
495	n/a	{
496	n/a	fpreg *addr = &stack->fp_regs[fpcount++];
497	n/a	float result;
498	n/a	avalue[i] = addr;
499	n/a	ldf_fill (result, addr);
500	n/a	(float )addr = result;
501	n/a	}
502	n/a	else
503	n/a	avalue[i] = endian_adjust(&stack->gp_regs[gpcount], 4);
504	n/a	gpcount++;
505	n/a	break;
506	n/a
507	n/a	case FFI_TYPE_DOUBLE:
508	n/a	if (gpcount < 8 && fpcount < 8)
509	n/a	{
510	n/a	fpreg *addr = &stack->fp_regs[fpcount++];
511	n/a	double result;
512	n/a	avalue[i] = addr;
513	n/a	ldf_fill (result, addr);
514	n/a	(double )addr = result;
515	n/a	}
516	n/a	else
517	n/a	avalue[i] = &stack->gp_regs[gpcount];
518	n/a	gpcount++;
519	n/a	break;
520	n/a
521	n/a	case FFI_TYPE_LONGDOUBLE:
522	n/a	if (gpcount & 1)
523	n/a	gpcount++;
524	n/a	if (LDBL_MANT_DIG == 64 && gpcount < 8 && fpcount < 8)
525	n/a	{
526	n/a	fpreg *addr = &stack->fp_regs[fpcount++];
527	n/a	__float80 result;
528	n/a	avalue[i] = addr;
529	n/a	ldf_fill (result, addr);
530	n/a	(__float80 )addr = result;
531	n/a	}
532	n/a	else
533	n/a	avalue[i] = &stack->gp_regs[gpcount];
534	n/a	gpcount += 2;
535	n/a	break;
536	n/a
537	n/a	case FFI_TYPE_STRUCT:
538	n/a	{
539	n/a	size_t size = (*p_arg)->size;
540	n/a	size_t align = (*p_arg)->alignment;
541	n/a	int hfa_type = hfa_element_type (*p_arg, 0);
542	n/a
543	n/a	FFI_ASSERT (align <= 16);
544	n/a	if (align == 16 && (gpcount & 1))
545	n/a	gpcount++;
546	n/a
547	n/a	if (hfa_type != FFI_TYPE_VOID)
548	n/a	{
549	n/a	size_t hfa_size = hfa_type_size (hfa_type);
550	n/a	size_t offset = 0;
551	n/a	size_t gp_offset = gpcount * 8;
552	n/a	void *addr = alloca (size);
553	n/a
554	n/a	avalue[i] = addr;
555	n/a
556	n/a	while (fpcount < 8
557	n/a	&& offset < size
558	n/a	&& gp_offset < 8 * 8)
559	n/a	{
560	n/a	hfa_type_store (hfa_type, addr + offset,
561	n/a	&stack->fp_regs[fpcount]);
562	n/a	offset += hfa_size;
563	n/a	gp_offset += hfa_size;
564	n/a	fpcount += 1;
565	n/a	}
566	n/a
567	n/a	if (offset < size)
568	n/a	memcpy (addr + offset, (char *)stack->gp_regs + gp_offset,
569	n/a	size - offset);
570	n/a	}
571	n/a	else
572	n/a	avalue[i] = &stack->gp_regs[gpcount];
573	n/a
574	n/a	gpcount += (size + 7) / 8;
575	n/a	}
576	n/a	break;
577	n/a
578	n/a	default:
579	n/a	abort ();
580	n/a	}
581	n/a	}
582	n/a
583	n/a	closure->fun (cif, rvalue, avalue, closure->user_data);
584	n/a
585	n/a	return cif->flags;
586	n/a	}