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

#	count	content
1	n/a	/* -----------------------------------------------------------------------
2	n/a	ffi.c - Copyright (c) 2002-2008, 2012 Kaz Kojima
3	n/a	Copyright (c) 2008 Red Hat, Inc.
4	n/a
5	n/a	SuperH Foreign Function Interface
6	n/a
7	n/a	Permission is hereby granted, free of charge, to any person obtaining
8	n/a	a copy of this software and associated documentation files (the
9	n/a	``Software''), to deal in the Software without restriction, including
10	n/a	without limitation the rights to use, copy, modify, merge, publish,
11	n/a	distribute, sublicense, and/or sell copies of the Software, and to
12	n/a	permit persons to whom the Software is furnished to do so, subject to
13	n/a	the following conditions:
14	n/a
15	n/a	The above copyright notice and this permission notice shall be included
16	n/a	in all copies or substantial portions of the Software.
17	n/a
18	n/a	THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
19	n/a	EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20	n/a	MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
21	n/a	NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
22	n/a	HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
23	n/a	WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24	n/a	OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
25	n/a	DEALINGS IN THE SOFTWARE.
26	n/a	----------------------------------------------------------------------- */
27	n/a
28	n/a	#include <ffi.h>
29	n/a	#include <ffi_common.h>
30	n/a
31	n/a	#include <stdlib.h>
32	n/a
33	n/a	#define NGREGARG 4
34	n/a	#if defined(__SH4__)
35	n/a	#define NFREGARG 8
36	n/a	#endif
37	n/a
38	n/a	#if defined(__HITACHI__)
39	n/a	#define STRUCT_VALUE_ADDRESS_WITH_ARG 1
40	n/a	#else
41	n/a	#define STRUCT_VALUE_ADDRESS_WITH_ARG 0
42	n/a	#endif
43	n/a
44	n/a	/* If the structure has essentially an unique element, return its type. */
45	n/a	static int
46	n/a	simple_type (ffi_type *arg)
47	n/a	{
48	n/a	if (arg->type != FFI_TYPE_STRUCT)
49	n/a	return arg->type;
50	n/a	else if (arg->elements[1])
51	n/a	return FFI_TYPE_STRUCT;
52	n/a
53	n/a	return simple_type (arg->elements[0]);
54	n/a	}
55	n/a
56	n/a	static int
57	n/a	return_type (ffi_type *arg)
58	n/a	{
59	n/a	unsigned short type;
60	n/a
61	n/a	if (arg->type != FFI_TYPE_STRUCT)
62	n/a	return arg->type;
63	n/a
64	n/a	type = simple_type (arg->elements[0]);
65	n/a	if (! arg->elements[1])
66	n/a	{
67	n/a	switch (type)
68	n/a	{
69	n/a	case FFI_TYPE_SINT8:
70	n/a	case FFI_TYPE_UINT8:
71	n/a	case FFI_TYPE_SINT16:
72	n/a	case FFI_TYPE_UINT16:
73	n/a	case FFI_TYPE_SINT32:
74	n/a	case FFI_TYPE_UINT32:
75	n/a	return FFI_TYPE_INT;
76	n/a
77	n/a	default:
78	n/a	return type;
79	n/a	}
80	n/a	}
81	n/a
82	n/a	/* gcc uses r0/r1 pair for some kind of structures. */
83	n/a	if (arg->size <= 2 * sizeof (int))
84	n/a	{
85	n/a	int i = 0;
86	n/a	ffi_type *e;
87	n/a
88	n/a	while ((e = arg->elements[i++]))
89	n/a	{
90	n/a	type = simple_type (e);
91	n/a	switch (type)
92	n/a	{
93	n/a	case FFI_TYPE_SINT32:
94	n/a	case FFI_TYPE_UINT32:
95	n/a	case FFI_TYPE_INT:
96	n/a	case FFI_TYPE_FLOAT:
97	n/a	return FFI_TYPE_UINT64;
98	n/a
99	n/a	default:
100	n/a	break;
101	n/a	}
102	n/a	}
103	n/a	}
104	n/a
105	n/a	return FFI_TYPE_STRUCT;
106	n/a	}
107	n/a
108	n/a	/* ffi_prep_args is called by the assembly routine once stack space
109	n/a	has been allocated for the function's arguments */
110	n/a
111	n/a	void ffi_prep_args(char stack, extended_cif ecif)
112	n/a	{
113	n/a	register unsigned int i;
114	n/a	register int tmp;
115	n/a	register unsigned int avn;
116	n/a	register void **p_argv;
117	n/a	register char *argp;
118	n/a	register ffi_type **p_arg;
119	n/a	int greg, ireg;
120	n/a	#if defined(__SH4__)
121	n/a	int freg = 0;
122	n/a	#endif
123	n/a
124	n/a	tmp = 0;
125	n/a	argp = stack;
126	n/a
127	n/a	if (return_type (ecif->cif->rtype) == FFI_TYPE_STRUCT)
128	n/a	{
129	n/a	(void *) argp = ecif->rvalue;
130	n/a	argp += 4;
131	n/a	ireg = STRUCT_VALUE_ADDRESS_WITH_ARG ? 1 : 0;
132	n/a	}
133	n/a	else
134	n/a	ireg = 0;
135	n/a
136	n/a	/* Set arguments for registers. */
137	n/a	greg = ireg;
138	n/a	avn = ecif->cif->nargs;
139	n/a	p_argv = ecif->avalue;
140	n/a
141	n/a	for (i = 0, p_arg = ecif->cif->arg_types; i < avn; i++, p_arg++, p_argv++)
142	n/a	{
143	n/a	size_t z;
144	n/a
145	n/a	z = (*p_arg)->size;
146	n/a	if (z < sizeof(int))
147	n/a	{
148	n/a	if (greg++ >= NGREGARG)
149	n/a	continue;
150	n/a
151	n/a	z = sizeof(int);
152	n/a	switch ((*p_arg)->type)
153	n/a	{
154	n/a	case FFI_TYPE_SINT8:
155	n/a	(signed int ) argp = (signed int)(SINT8 )(* p_argv);
156	n/a	break;
157	n/a
158	n/a	case FFI_TYPE_UINT8:
159	n/a	(unsigned int ) argp = (unsigned int)(UINT8 )(* p_argv);
160	n/a	break;
161	n/a
162	n/a	case FFI_TYPE_SINT16:
163	n/a	(signed int ) argp = (signed int)(SINT16 )(* p_argv);
164	n/a	break;
165	n/a
166	n/a	case FFI_TYPE_UINT16:
167	n/a	(unsigned int ) argp = (unsigned int)(UINT16 )(* p_argv);
168	n/a	break;
169	n/a
170	n/a	case FFI_TYPE_STRUCT:
171	n/a	(unsigned int ) argp = (unsigned int)(UINT32 )(* p_argv);
172	n/a	break;
173	n/a
174	n/a	default:
175	n/a	FFI_ASSERT(0);
176	n/a	}
177	n/a	argp += z;
178	n/a	}
179	n/a	else if (z == sizeof(int))
180	n/a	{
181	n/a	#if defined(__SH4__)
182	n/a	if ((*p_arg)->type == FFI_TYPE_FLOAT)
183	n/a	{
184	n/a	if (freg++ >= NFREGARG)
185	n/a	continue;
186	n/a	}
187	n/a	else
188	n/a	#endif
189	n/a	{
190	n/a	if (greg++ >= NGREGARG)
191	n/a	continue;
192	n/a	}
193	n/a	(unsigned int ) argp = (unsigned int)(UINT32 )(* p_argv);
194	n/a	argp += z;
195	n/a	}
196	n/a	#if defined(__SH4__)
197	n/a	else if ((*p_arg)->type == FFI_TYPE_DOUBLE)
198	n/a	{
199	n/a	if (freg + 1 >= NFREGARG)
200	n/a	continue;
201	n/a	freg = (freg + 1) & ~1;
202	n/a	freg += 2;
203	n/a	memcpy (argp, *p_argv, z);
204	n/a	argp += z;
205	n/a	}
206	n/a	#endif
207	n/a	else
208	n/a	{
209	n/a	int n = (z + sizeof (int) - 1) / sizeof (int);
210	n/a	#if defined(__SH4__)
211	n/a	if (greg + n - 1 >= NGREGARG)
212	n/a	continue;
213	n/a	#else
214	n/a	if (greg >= NGREGARG)
215	n/a	continue;
216	n/a	#endif
217	n/a	greg += n;
218	n/a	memcpy (argp, *p_argv, z);
219	n/a	argp += n * sizeof (int);
220	n/a	}
221	n/a	}
222	n/a
223	n/a	/* Set arguments on stack. */
224	n/a	greg = ireg;
225	n/a	#if defined(__SH4__)
226	n/a	freg = 0;
227	n/a	#endif
228	n/a	p_argv = ecif->avalue;
229	n/a
230	n/a	for (i = 0, p_arg = ecif->cif->arg_types; i < avn; i++, p_arg++, p_argv++)
231	n/a	{
232	n/a	size_t z;
233	n/a
234	n/a	z = (*p_arg)->size;
235	n/a	if (z < sizeof(int))
236	n/a	{
237	n/a	if (greg++ < NGREGARG)
238	n/a	continue;
239	n/a
240	n/a	z = sizeof(int);
241	n/a	switch ((*p_arg)->type)
242	n/a	{
243	n/a	case FFI_TYPE_SINT8:
244	n/a	(signed int ) argp = (signed int)(SINT8 )(* p_argv);
245	n/a	break;
246	n/a
247	n/a	case FFI_TYPE_UINT8:
248	n/a	(unsigned int ) argp = (unsigned int)(UINT8 )(* p_argv);
249	n/a	break;
250	n/a
251	n/a	case FFI_TYPE_SINT16:
252	n/a	(signed int ) argp = (signed int)(SINT16 )(* p_argv);
253	n/a	break;
254	n/a
255	n/a	case FFI_TYPE_UINT16:
256	n/a	(unsigned int ) argp = (unsigned int)(UINT16 )(* p_argv);
257	n/a	break;
258	n/a
259	n/a	case FFI_TYPE_STRUCT:
260	n/a	(unsigned int ) argp = (unsigned int)(UINT32 )(* p_argv);
261	n/a	break;
262	n/a
263	n/a	default:
264	n/a	FFI_ASSERT(0);
265	n/a	}
266	n/a	argp += z;
267	n/a	}
268	n/a	else if (z == sizeof(int))
269	n/a	{
270	n/a	#if defined(__SH4__)
271	n/a	if ((*p_arg)->type == FFI_TYPE_FLOAT)
272	n/a	{
273	n/a	if (freg++ < NFREGARG)
274	n/a	continue;
275	n/a	}
276	n/a	else
277	n/a	#endif
278	n/a	{
279	n/a	if (greg++ < NGREGARG)
280	n/a	continue;
281	n/a	}
282	n/a	(unsigned int ) argp = (unsigned int)(UINT32 )(* p_argv);
283	n/a	argp += z;
284	n/a	}
285	n/a	#if defined(__SH4__)
286	n/a	else if ((*p_arg)->type == FFI_TYPE_DOUBLE)
287	n/a	{
288	n/a	if (freg + 1 < NFREGARG)
289	n/a	{
290	n/a	freg = (freg + 1) & ~1;
291	n/a	freg += 2;
292	n/a	continue;
293	n/a	}
294	n/a	memcpy (argp, *p_argv, z);
295	n/a	argp += z;
296	n/a	}
297	n/a	#endif
298	n/a	else
299	n/a	{
300	n/a	int n = (z + sizeof (int) - 1) / sizeof (int);
301	n/a	if (greg + n - 1 < NGREGARG)
302	n/a	{
303	n/a	greg += n;
304	n/a	continue;
305	n/a	}
306	n/a	#if (! defined(__SH4__))
307	n/a	else if (greg < NGREGARG)
308	n/a	{
309	n/a	greg = NGREGARG;
310	n/a	continue;
311	n/a	}
312	n/a	#endif
313	n/a	memcpy (argp, *p_argv, z);
314	n/a	argp += n * sizeof (int);
315	n/a	}
316	n/a	}
317	n/a
318	n/a	return;
319	n/a	}
320	n/a
321	n/a	/* Perform machine dependent cif processing */
322	n/a	ffi_status ffi_prep_cif_machdep(ffi_cif *cif)
323	n/a	{
324	n/a	int i, j;
325	n/a	int size, type;
326	n/a	int n, m;
327	n/a	int greg;
328	n/a	#if defined(__SH4__)
329	n/a	int freg = 0;
330	n/a	#endif
331	n/a
332	n/a	cif->flags = 0;
333	n/a
334	n/a	greg = ((return_type (cif->rtype) == FFI_TYPE_STRUCT) &&
335	n/a	STRUCT_VALUE_ADDRESS_WITH_ARG) ? 1 : 0;
336	n/a
337	n/a	#if defined(__SH4__)
338	n/a	for (i = j = 0; i < cif->nargs && j < 12; i++)
339	n/a	{
340	n/a	type = (cif->arg_types)[i]->type;
341	n/a	switch (type)
342	n/a	{
343	n/a	case FFI_TYPE_FLOAT:
344	n/a	if (freg >= NFREGARG)
345	n/a	continue;
346	n/a	freg++;
347	n/a	cif->flags += ((cif->arg_types)[i]->type) << (2 * j);
348	n/a	j++;
349	n/a	break;
350	n/a
351	n/a	case FFI_TYPE_DOUBLE:
352	n/a	if ((freg + 1) >= NFREGARG)
353	n/a	continue;
354	n/a	freg = (freg + 1) & ~1;
355	n/a	freg += 2;
356	n/a	cif->flags += ((cif->arg_types)[i]->type) << (2 * j);
357	n/a	j++;
358	n/a	break;
359	n/a
360	n/a	default:
361	n/a	size = (cif->arg_types)[i]->size;
362	n/a	n = (size + sizeof (int) - 1) / sizeof (int);
363	n/a	if (greg + n - 1 >= NGREGARG)
364	n/a	continue;
365	n/a	greg += n;
366	n/a	for (m = 0; m < n; m++)
367	n/a	cif->flags += FFI_TYPE_INT << (2 * j++);
368	n/a	break;
369	n/a	}
370	n/a	}
371	n/a	#else
372	n/a	for (i = j = 0; i < cif->nargs && j < 4; i++)
373	n/a	{
374	n/a	size = (cif->arg_types)[i]->size;
375	n/a	n = (size + sizeof (int) - 1) / sizeof (int);
376	n/a	if (greg >= NGREGARG)
377	n/a	continue;
378	n/a	else if (greg + n - 1 >= NGREGARG)
379	n/a	n = NGREGARG - greg;
380	n/a	greg += n;
381	n/a	for (m = 0; m < n; m++)
382	n/a	cif->flags += FFI_TYPE_INT << (2 * j++);
383	n/a	}
384	n/a	#endif
385	n/a
386	n/a	/* Set the return type flag */
387	n/a	switch (cif->rtype->type)
388	n/a	{
389	n/a	case FFI_TYPE_STRUCT:
390	n/a	cif->flags += (unsigned) (return_type (cif->rtype)) << 24;
391	n/a	break;
392	n/a
393	n/a	case FFI_TYPE_VOID:
394	n/a	case FFI_TYPE_FLOAT:
395	n/a	case FFI_TYPE_DOUBLE:
396	n/a	case FFI_TYPE_SINT64:
397	n/a	case FFI_TYPE_UINT64:
398	n/a	cif->flags += (unsigned) cif->rtype->type << 24;
399	n/a	break;
400	n/a
401	n/a	default:
402	n/a	cif->flags += FFI_TYPE_INT << 24;
403	n/a	break;
404	n/a	}
405	n/a
406	n/a	return FFI_OK;
407	n/a	}
408	n/a
409	n/a	extern void ffi_call_SYSV(void ()(char , extended_cif ), extended_cif ,
410	n/a	unsigned, unsigned, unsigned , void (fn)(void));
411	n/a
412	n/a	void ffi_call(ffi_cif cif, void (fn)(void), void rvalue, void *avalue)
413	n/a	{
414	n/a	extended_cif ecif;
415	n/a	UINT64 trvalue;
416	n/a
417	n/a	ecif.cif = cif;
418	n/a	ecif.avalue = avalue;
419	n/a
420	n/a	/* If the return value is a struct and we don't have a return */
421	n/a	/* value address then we need to make one */
422	n/a
423	n/a	if (cif->rtype->type == FFI_TYPE_STRUCT
424	n/a	&& return_type (cif->rtype) != FFI_TYPE_STRUCT)
425	n/a	ecif.rvalue = &trvalue;
426	n/a	else if ((rvalue == NULL) &&
427	n/a	(cif->rtype->type == FFI_TYPE_STRUCT))
428	n/a	{
429	n/a	ecif.rvalue = alloca(cif->rtype->size);
430	n/a	}
431	n/a	else
432	n/a	ecif.rvalue = rvalue;
433	n/a
434	n/a	switch (cif->abi)
435	n/a	{
436	n/a	case FFI_SYSV:
437	n/a	ffi_call_SYSV(ffi_prep_args, &ecif, cif->bytes, cif->flags, ecif.rvalue,
438	n/a	fn);
439	n/a	break;
440	n/a	default:
441	n/a	FFI_ASSERT(0);
442	n/a	break;
443	n/a	}
444	n/a
445	n/a	if (rvalue
446	n/a	&& cif->rtype->type == FFI_TYPE_STRUCT
447	n/a	&& return_type (cif->rtype) != FFI_TYPE_STRUCT)
448	n/a	memcpy (rvalue, &trvalue, cif->rtype->size);
449	n/a	}
450	n/a
451	n/a	extern void ffi_closure_SYSV (void);
452	n/a	#if defined(__SH4__)
453	n/a	extern void __ic_invalidate (void *line);
454	n/a	#endif
455	n/a
456	n/a	ffi_status
457	n/a	ffi_prep_closure_loc (ffi_closure* closure,
458	n/a	ffi_cif* cif,
459	n/a	void (fun)(ffi_cif, void, void, void),
460	n/a	void *user_data,
461	n/a	void *codeloc)
462	n/a	{
463	n/a	unsigned int *tramp;
464	n/a	unsigned int insn;
465	n/a
466	n/a	if (cif->abi != FFI_SYSV)
467	n/a	return FFI_BAD_ABI;
468	n/a
469	n/a	tramp = (unsigned int *) &closure->tramp[0];
470	n/a	/* Set T bit if the function returns a struct pointed with R2. */
471	n/a	insn = (return_type (cif->rtype) == FFI_TYPE_STRUCT
472	n/a	? 0x0018 /* sett */
473	n/a	: 0x0008 /* clrt */);
474	n/a
475	n/a	#ifdef __LITTLE_ENDIAN__
476	n/a	tramp[0] = 0xd301d102;
477	n/a	tramp[1] = 0x0000412b \| (insn << 16);
478	n/a	#else
479	n/a	tramp[0] = 0xd102d301;
480	n/a	tramp[1] = 0x412b0000 \| insn;
481	n/a	#endif
482	n/a	(void ) &tramp[2] = (void )codeloc; /* ctx */
483	n/a	(void ) &tramp[3] = (void )ffi_closure_SYSV; /* funaddr */
484	n/a
485	n/a	closure->cif = cif;
486	n/a	closure->fun = fun;
487	n/a	closure->user_data = user_data;
488	n/a
489	n/a	#if defined(__SH4__)
490	n/a	/* Flush the icache. */
491	n/a	__ic_invalidate(codeloc);
492	n/a	#endif
493	n/a
494	n/a	return FFI_OK;
495	n/a	}
496	n/a
497	n/a	/* Basically the trampoline invokes ffi_closure_SYSV, and on
498	n/a	* entry, r3 holds the address of the closure.
499	n/a	* After storing the registers that could possibly contain
500	n/a	* parameters to be passed into the stack frame and setting
501	n/a	* up space for a return value, ffi_closure_SYSV invokes the
502	n/a	* following helper function to do most of the work.
503	n/a	*/
504	n/a
505	n/a	#ifdef __LITTLE_ENDIAN__
506	n/a	#define OFS_INT8 0
507	n/a	#define OFS_INT16 0
508	n/a	#else
509	n/a	#define OFS_INT8 3
510	n/a	#define OFS_INT16 2
511	n/a	#endif
512	n/a
513	n/a	int
514	n/a	ffi_closure_helper_SYSV (ffi_closure closure, void rvalue,
515	n/a	unsigned long pgr, unsigned long pfr,
516	n/a	unsigned long *pst)
517	n/a	{
518	n/a	void **avalue;
519	n/a	ffi_type **p_arg;
520	n/a	int i, avn;
521	n/a	int ireg, greg = 0;
522	n/a	#if defined(__SH4__)
523	n/a	int freg = 0;
524	n/a	#endif
525	n/a	ffi_cif *cif;
526	n/a
527	n/a	cif = closure->cif;
528	n/a	avalue = alloca(cif->nargs * sizeof(void *));
529	n/a
530	n/a	/* Copy the caller's structure return value address so that the closure
531	n/a	returns the data directly to the caller. */
532	n/a	if (cif->rtype->type == FFI_TYPE_STRUCT && STRUCT_VALUE_ADDRESS_WITH_ARG)
533	n/a	{
534	n/a	rvalue = (void ) pgr++;
535	n/a	ireg = 1;
536	n/a	}
537	n/a	else
538	n/a	ireg = 0;
539	n/a
540	n/a	cif = closure->cif;
541	n/a	greg = ireg;
542	n/a	avn = cif->nargs;
543	n/a
544	n/a	/* Grab the addresses of the arguments from the stack frame. */
545	n/a	for (i = 0, p_arg = cif->arg_types; i < avn; i++, p_arg++)
546	n/a	{
547	n/a	size_t z;
548	n/a
549	n/a	z = (*p_arg)->size;
550	n/a	if (z < sizeof(int))
551	n/a	{
552	n/a	if (greg++ >= NGREGARG)
553	n/a	continue;
554	n/a
555	n/a	z = sizeof(int);
556	n/a	switch ((*p_arg)->type)
557	n/a	{
558	n/a	case FFI_TYPE_SINT8:
559	n/a	case FFI_TYPE_UINT8:
560	n/a	avalue[i] = (((char *)pgr) + OFS_INT8);
561	n/a	break;
562	n/a
563	n/a	case FFI_TYPE_SINT16:
564	n/a	case FFI_TYPE_UINT16:
565	n/a	avalue[i] = (((char *)pgr) + OFS_INT16);
566	n/a	break;
567	n/a
568	n/a	case FFI_TYPE_STRUCT:
569	n/a	avalue[i] = pgr;
570	n/a	break;
571	n/a
572	n/a	default:
573	n/a	FFI_ASSERT(0);
574	n/a	}
575	n/a	pgr++;
576	n/a	}
577	n/a	else if (z == sizeof(int))
578	n/a	{
579	n/a	#if defined(__SH4__)
580	n/a	if ((*p_arg)->type == FFI_TYPE_FLOAT)
581	n/a	{
582	n/a	if (freg++ >= NFREGARG)
583	n/a	continue;
584	n/a	avalue[i] = pfr;
585	n/a	pfr++;
586	n/a	}
587	n/a	else
588	n/a	#endif
589	n/a	{
590	n/a	if (greg++ >= NGREGARG)
591	n/a	continue;
592	n/a	avalue[i] = pgr;
593	n/a	pgr++;
594	n/a	}
595	n/a	}
596	n/a	#if defined(__SH4__)
597	n/a	else if ((*p_arg)->type == FFI_TYPE_DOUBLE)
598	n/a	{
599	n/a	if (freg + 1 >= NFREGARG)
600	n/a	continue;
601	n/a	if (freg & 1)
602	n/a	pfr++;
603	n/a	freg = (freg + 1) & ~1;
604	n/a	freg += 2;
605	n/a	avalue[i] = pfr;
606	n/a	pfr += 2;
607	n/a	}
608	n/a	#endif
609	n/a	else
610	n/a	{
611	n/a	int n = (z + sizeof (int) - 1) / sizeof (int);
612	n/a	#if defined(__SH4__)
613	n/a	if (greg + n - 1 >= NGREGARG)
614	n/a	continue;
615	n/a	#else
616	n/a	if (greg >= NGREGARG)
617	n/a	continue;
618	n/a	#endif
619	n/a	greg += n;
620	n/a	avalue[i] = pgr;
621	n/a	pgr += n;
622	n/a	}
623	n/a	}
624	n/a
625	n/a	greg = ireg;
626	n/a	#if defined(__SH4__)
627	n/a	freg = 0;
628	n/a	#endif
629	n/a
630	n/a	for (i = 0, p_arg = cif->arg_types; i < avn; i++, p_arg++)
631	n/a	{
632	n/a	size_t z;
633	n/a
634	n/a	z = (*p_arg)->size;
635	n/a	if (z < sizeof(int))
636	n/a	{
637	n/a	if (greg++ < NGREGARG)
638	n/a	continue;
639	n/a
640	n/a	z = sizeof(int);
641	n/a	switch ((*p_arg)->type)
642	n/a	{
643	n/a	case FFI_TYPE_SINT8:
644	n/a	case FFI_TYPE_UINT8:
645	n/a	avalue[i] = (((char *)pst) + OFS_INT8);
646	n/a	break;
647	n/a
648	n/a	case FFI_TYPE_SINT16:
649	n/a	case FFI_TYPE_UINT16:
650	n/a	avalue[i] = (((char *)pst) + OFS_INT16);
651	n/a	break;
652	n/a
653	n/a	case FFI_TYPE_STRUCT:
654	n/a	avalue[i] = pst;
655	n/a	break;
656	n/a
657	n/a	default:
658	n/a	FFI_ASSERT(0);
659	n/a	}
660	n/a	pst++;
661	n/a	}
662	n/a	else if (z == sizeof(int))
663	n/a	{
664	n/a	#if defined(__SH4__)
665	n/a	if ((*p_arg)->type == FFI_TYPE_FLOAT)
666	n/a	{
667	n/a	if (freg++ < NFREGARG)
668	n/a	continue;
669	n/a	}
670	n/a	else
671	n/a	#endif
672	n/a	{
673	n/a	if (greg++ < NGREGARG)
674	n/a	continue;
675	n/a	}
676	n/a	avalue[i] = pst;
677	n/a	pst++;
678	n/a	}
679	n/a	#if defined(__SH4__)
680	n/a	else if ((*p_arg)->type == FFI_TYPE_DOUBLE)
681	n/a	{
682	n/a	if (freg + 1 < NFREGARG)
683	n/a	{
684	n/a	freg = (freg + 1) & ~1;
685	n/a	freg += 2;
686	n/a	continue;
687	n/a	}
688	n/a	avalue[i] = pst;
689	n/a	pst += 2;
690	n/a	}
691	n/a	#endif
692	n/a	else
693	n/a	{
694	n/a	int n = (z + sizeof (int) - 1) / sizeof (int);
695	n/a	if (greg + n - 1 < NGREGARG)
696	n/a	{
697	n/a	greg += n;
698	n/a	continue;
699	n/a	}
700	n/a	#if (! defined(__SH4__))
701	n/a	else if (greg < NGREGARG)
702	n/a	{
703	n/a	greg += n;
704	n/a	pst += greg - NGREGARG;
705	n/a	continue;
706	n/a	}
707	n/a	#endif
708	n/a	avalue[i] = pst;
709	n/a	pst += n;
710	n/a	}
711	n/a	}
712	n/a
713	n/a	(closure->fun) (cif, rvalue, avalue, closure->user_data);
714	n/a
715	n/a	/* Tell ffi_closure_SYSV how to perform return type promotions. */
716	n/a	return return_type (cif->rtype);
717	n/a	}