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

#	count	content
1	n/a	/* -----------------------------------------------------------------------
2	n/a	ffi.c - Copyright (c) 1996, 1998, 1999, 2001, 2007, 2008 Red Hat, Inc.
3	n/a	Copyright (c) 2002 Ranjit Mathew
4	n/a	Copyright (c) 2002 Bo Thorsen
5	n/a	Copyright (c) 2002 Roger Sayle
6	n/a	Copyright (C) 2008, 2010 Free Software Foundation, Inc.
7	n/a
8	n/a	x86 Foreign Function Interface
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,
22	n/a	EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
23	n/a	MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
24	n/a	NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
25	n/a	HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
26	n/a	WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
27	n/a	OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
28	n/a	DEALINGS IN THE SOFTWARE.
29	n/a	----------------------------------------------------------------------- */
30	n/a
31	n/a	#if !defined(__x86_64__) \|\| defined(_WIN64)
32	n/a
33	n/a	#ifdef _WIN64
34	n/a	#include <windows.h>
35	n/a	#endif
36	n/a
37	n/a	#include <ffi.h>
38	n/a	#include <ffi_common.h>
39	n/a
40	n/a	#include <stdlib.h>
41	n/a
42	n/a
43	n/a	/* ffi_prep_args is called by the assembly routine once stack space
44	n/a	has been allocated for the function's arguments */
45	n/a
46	n/a	void ffi_prep_args(char stack, extended_cif ecif);
47	n/a	void ffi_prep_args(char stack, extended_cif ecif)
48	n/a	{
49	n/a	register unsigned int i;
50	n/a	register void **p_argv;
51	n/a	register char *argp;
52	n/a	register ffi_type **p_arg;
53	n/a	#ifndef X86_WIN64
54	n/a	size_t p_stack_args[2];
55	n/a	void *p_stack_data[2];
56	n/a	char *argp2 = stack;
57	n/a	int stack_args_count = 0;
58	n/a	int cabi = ecif->cif->abi;
59	n/a	#endif
60	n/a
61	n/a	argp = stack;
62	n/a
63	n/a	if ((ecif->cif->flags == FFI_TYPE_STRUCT
64	n/a	\|\| ecif->cif->flags == FFI_TYPE_MS_STRUCT)
65	n/a	#ifdef X86_WIN64
66	n/a	&& (ecif->cif->rtype->size != 1 && ecif->cif->rtype->size != 2
67	n/a	&& ecif->cif->rtype->size != 4 && ecif->cif->rtype->size != 8)
68	n/a	#endif
69	n/a	)
70	n/a	{
71	n/a	(void *) argp = ecif->rvalue;
72	n/a	#ifndef X86_WIN64
73	n/a	/* For fastcall/thiscall this is first register-passed
74	n/a	argument. */
75	n/a	if (cabi == FFI_THISCALL \|\| cabi == FFI_FASTCALL)
76	n/a	{
77	n/a	p_stack_args[stack_args_count] = sizeof (void*);
78	n/a	p_stack_data[stack_args_count] = argp;
79	n/a	++stack_args_count;
80	n/a	}
81	n/a	#endif
82	n/a	argp += sizeof(void*);
83	n/a	}
84	n/a
85	n/a	p_argv = ecif->avalue;
86	n/a
87	n/a	for (i = ecif->cif->nargs, p_arg = ecif->cif->arg_types;
88	n/a	i != 0;
89	n/a	i--, p_arg++)
90	n/a	{
91	n/a	size_t z;
92	n/a
93	n/a	/* Align if necessary */
94	n/a	if ((sizeof(void*) - 1) & (size_t) argp)
95	n/a	argp = (char ) ALIGN(argp, sizeof(void));
96	n/a
97	n/a	z = (*p_arg)->size;
98	n/a	#ifdef X86_WIN64
99	n/a	if (z > sizeof(ffi_arg)
100	n/a	\|\| ((*p_arg)->type == FFI_TYPE_STRUCT
101	n/a	&& (z != 1 && z != 2 && z != 4 && z != 8))
102	n/a	#if FFI_TYPE_DOUBLE != FFI_TYPE_LONGDOUBLE
103	n/a	\|\| ((*p_arg)->type == FFI_TYPE_LONGDOUBLE)
104	n/a	#endif
105	n/a	)
106	n/a	{
107	n/a	z = sizeof(ffi_arg);
108	n/a	(void )argp = p_argv;
109	n/a	}
110	n/a	else if ((*p_arg)->type == FFI_TYPE_FLOAT)
111	n/a	{
112	n/a	memcpy(argp, *p_argv, z);
113	n/a	}
114	n/a	else
115	n/a	#endif
116	n/a	if (z < sizeof(ffi_arg))
117	n/a	{
118	n/a	z = sizeof(ffi_arg);
119	n/a	switch ((*p_arg)->type)
120	n/a	{
121	n/a	case FFI_TYPE_SINT8:
122	n/a	(ffi_sarg ) argp = (ffi_sarg)(SINT8 )(* p_argv);
123	n/a	break;
124	n/a
125	n/a	case FFI_TYPE_UINT8:
126	n/a	(ffi_arg ) argp = (ffi_arg)(UINT8 )(* p_argv);
127	n/a	break;
128	n/a
129	n/a	case FFI_TYPE_SINT16:
130	n/a	(ffi_sarg ) argp = (ffi_sarg)(SINT16 )(* p_argv);
131	n/a	break;
132	n/a
133	n/a	case FFI_TYPE_UINT16:
134	n/a	(ffi_arg ) argp = (ffi_arg)(UINT16 )(* p_argv);
135	n/a	break;
136	n/a
137	n/a	case FFI_TYPE_SINT32:
138	n/a	(ffi_sarg ) argp = (ffi_sarg)(SINT32 )(* p_argv);
139	n/a	break;
140	n/a
141	n/a	case FFI_TYPE_UINT32:
142	n/a	(ffi_arg ) argp = (ffi_arg)(UINT32 )(* p_argv);
143	n/a	break;
144	n/a
145	n/a	case FFI_TYPE_STRUCT:
146	n/a	(ffi_arg ) argp = (ffi_arg )(* p_argv);
147	n/a	break;
148	n/a
149	n/a	default:
150	n/a	FFI_ASSERT(0);
151	n/a	}
152	n/a	}
153	n/a	else
154	n/a	{
155	n/a	memcpy(argp, *p_argv, z);
156	n/a	}
157	n/a
158	n/a	#ifndef X86_WIN64
159	n/a	/* For thiscall/fastcall convention register-passed arguments
160	n/a	are the first two none-floating-point arguments with a size
161	n/a	smaller or equal to sizeof (void). /
162	n/a	if ((cabi == FFI_THISCALL && stack_args_count < 1)
163	n/a	\|\| (cabi == FFI_FASTCALL && stack_args_count < 2))
164	n/a	{
165	n/a	if (z <= 4
166	n/a	&& ((*p_arg)->type != FFI_TYPE_FLOAT
167	n/a	&& (*p_arg)->type != FFI_TYPE_STRUCT))
168	n/a	{
169	n/a	p_stack_args[stack_args_count] = z;
170	n/a	p_stack_data[stack_args_count] = argp;
171	n/a	++stack_args_count;
172	n/a	}
173	n/a	}
174	n/a	#endif
175	n/a	p_argv++;
176	n/a	#ifdef X86_WIN64
177	n/a	argp += (z + sizeof(void) - 1) & ~(sizeof(void) - 1);
178	n/a	#else
179	n/a	argp += z;
180	n/a	#endif
181	n/a	}
182	n/a
183	n/a	#ifndef X86_WIN64
184	n/a	/* We need to move the register-passed arguments for thiscall/fastcall
185	n/a	on top of stack, so that those can be moved to registers ecx/edx by
186	n/a	call-handler. */
187	n/a	if (stack_args_count > 0)
188	n/a	{
189	n/a	size_t zz = (p_stack_args[0] + 3) & ~3;
190	n/a	char *h;
191	n/a
192	n/a	/* Move first argument to top-stack position. */
193	n/a	if (p_stack_data[0] != argp2)
194	n/a	{
195	n/a	h = alloca (zz + 1);
196	n/a	memcpy (h, p_stack_data[0], zz);
197	n/a	memmove (argp2 + zz, argp2,
198	n/a	(size_t) ((char ) p_stack_data[0] - (char)argp2));
199	n/a	memcpy (argp2, h, zz);
200	n/a	}
201	n/a
202	n/a	argp2 += zz;
203	n/a	--stack_args_count;
204	n/a	if (zz > 4)
205	n/a	stack_args_count = 0;
206	n/a
207	n/a	/* If we have a second argument, then move it on top
208	n/a	after the first one. */
209	n/a	if (stack_args_count > 0 && p_stack_data[1] != argp2)
210	n/a	{
211	n/a	zz = p_stack_args[1];
212	n/a	zz = (zz + 3) & ~3;
213	n/a	h = alloca (zz + 1);
214	n/a	h = alloca (zz + 1);
215	n/a	memcpy (h, p_stack_data[1], zz);
216	n/a	memmove (argp2 + zz, argp2, (size_t) ((char) p_stack_data[1] - (char)argp2));
217	n/a	memcpy (argp2, h, zz);
218	n/a	}
219	n/a	}
220	n/a	#endif
221	n/a	return;
222	n/a	}
223	n/a
224	n/a	/* Perform machine dependent cif processing */
225	n/a	ffi_status ffi_prep_cif_machdep(ffi_cif *cif)
226	n/a	{
227	n/a	unsigned int i;
228	n/a	ffi_type **ptr;
229	n/a
230	n/a	/* Set the return type flag */
231	n/a	switch (cif->rtype->type)
232	n/a	{
233	n/a	case FFI_TYPE_VOID:
234	n/a	case FFI_TYPE_UINT8:
235	n/a	case FFI_TYPE_UINT16:
236	n/a	case FFI_TYPE_SINT8:
237	n/a	case FFI_TYPE_SINT16:
238	n/a	#ifdef X86_WIN64
239	n/a	case FFI_TYPE_UINT32:
240	n/a	case FFI_TYPE_SINT32:
241	n/a	#endif
242	n/a	case FFI_TYPE_SINT64:
243	n/a	case FFI_TYPE_FLOAT:
244	n/a	case FFI_TYPE_DOUBLE:
245	n/a	#ifndef X86_WIN64
246	n/a	#if FFI_TYPE_DOUBLE != FFI_TYPE_LONGDOUBLE
247	n/a	case FFI_TYPE_LONGDOUBLE:
248	n/a	#endif
249	n/a	#endif
250	n/a	cif->flags = (unsigned) cif->rtype->type;
251	n/a	break;
252	n/a
253	n/a	case FFI_TYPE_UINT64:
254	n/a	#ifdef X86_WIN64
255	n/a	case FFI_TYPE_POINTER:
256	n/a	#endif
257	n/a	cif->flags = FFI_TYPE_SINT64;
258	n/a	break;
259	n/a
260	n/a	case FFI_TYPE_STRUCT:
261	n/a	#ifndef X86
262	n/a	if (cif->rtype->size == 1)
263	n/a	{
264	n/a	cif->flags = FFI_TYPE_SMALL_STRUCT_1B; /* same as char size */
265	n/a	}
266	n/a	else if (cif->rtype->size == 2)
267	n/a	{
268	n/a	cif->flags = FFI_TYPE_SMALL_STRUCT_2B; /* same as short size */
269	n/a	}
270	n/a	else if (cif->rtype->size == 4)
271	n/a	{
272	n/a	#ifdef X86_WIN64
273	n/a	cif->flags = FFI_TYPE_SMALL_STRUCT_4B;
274	n/a	#else
275	n/a	cif->flags = FFI_TYPE_INT; /* same as int type */
276	n/a	#endif
277	n/a	}
278	n/a	else if (cif->rtype->size == 8)
279	n/a	{
280	n/a	cif->flags = FFI_TYPE_SINT64; /* same as int64 type */
281	n/a	}
282	n/a	else
283	n/a	#endif
284	n/a	{
285	n/a	#ifdef X86_WIN32
286	n/a	if (cif->abi == FFI_MS_CDECL)
287	n/a	cif->flags = FFI_TYPE_MS_STRUCT;
288	n/a	else
289	n/a	#endif
290	n/a	cif->flags = FFI_TYPE_STRUCT;
291	n/a	/* allocate space for return value pointer */
292	n/a	cif->bytes += ALIGN(sizeof(void*), FFI_SIZEOF_ARG);
293	n/a	}
294	n/a	break;
295	n/a
296	n/a	default:
297	n/a	#ifdef X86_WIN64
298	n/a	cif->flags = FFI_TYPE_SINT64;
299	n/a	break;
300	n/a	case FFI_TYPE_INT:
301	n/a	cif->flags = FFI_TYPE_SINT32;
302	n/a	#else
303	n/a	cif->flags = FFI_TYPE_INT;
304	n/a	#endif
305	n/a	break;
306	n/a	}
307	n/a
308	n/a	for (ptr = cif->arg_types, i = cif->nargs; i > 0; i--, ptr++)
309	n/a	{
310	n/a	if (((*ptr)->alignment - 1) & cif->bytes)
311	n/a	cif->bytes = ALIGN(cif->bytes, (*ptr)->alignment);
312	n/a	cif->bytes += (unsigned)ALIGN((*ptr)->size, FFI_SIZEOF_ARG);
313	n/a	}
314	n/a
315	n/a	#ifdef X86_WIN64
316	n/a	/* ensure space for storing four registers */
317	n/a	cif->bytes += 4 * sizeof(ffi_arg);
318	n/a	#endif
319	n/a
320	n/a	#ifndef X86_WIN32
321	n/a	#ifndef X86_WIN64
322	n/a	if (cif->abi != FFI_STDCALL && cif->abi != FFI_THISCALL && cif->abi != FFI_FASTCALL)
323	n/a	#endif
324	n/a	cif->bytes = (cif->bytes + 15) & ~0xF;
325	n/a	#endif
326	n/a
327	n/a	return FFI_OK;
328	n/a	}
329	n/a
330	n/a	#ifdef X86_WIN64
331	n/a	extern int
332	n/a	ffi_call_win64(void ()(char , extended_cif ), extended_cif ,
333	n/a	unsigned, unsigned, unsigned , void (fn)(void));
334	n/a	#elif defined(X86_WIN32)
335	n/a	extern void
336	n/a	ffi_call_win32(void ()(char , extended_cif ), extended_cif ,
337	n/a	unsigned, unsigned, unsigned, unsigned , void (fn)(void));
338	n/a	#else
339	n/a	extern void ffi_call_SYSV(void ()(char , extended_cif ), extended_cif ,
340	n/a	unsigned, unsigned, unsigned , void (fn)(void));
341	n/a	#endif
342	n/a
343	n/a	void ffi_call(ffi_cif cif, void (fn)(void), void rvalue, void *avalue)
344	n/a	{
345	n/a	extended_cif ecif;
346	n/a
347	n/a	ecif.cif = cif;
348	n/a	ecif.avalue = avalue;
349	n/a
350	n/a	/* If the return value is a struct and we don't have a return */
351	n/a	/* value address then we need to make one */
352	n/a
353	n/a	#ifdef X86_WIN64
354	n/a	if (rvalue == NULL
355	n/a	&& cif->flags == FFI_TYPE_STRUCT
356	n/a	&& cif->rtype->size != 1 && cif->rtype->size != 2
357	n/a	&& cif->rtype->size != 4 && cif->rtype->size != 8)
358	n/a	{
359	n/a	ecif.rvalue = alloca((cif->rtype->size + 0xF) & ~0xF);
360	n/a	}
361	n/a	#else
362	n/a	if (rvalue == NULL
363	n/a	&& (cif->flags == FFI_TYPE_STRUCT
364	n/a	\|\| cif->flags == FFI_TYPE_MS_STRUCT))
365	n/a	{
366	n/a	ecif.rvalue = alloca(cif->rtype->size);
367	n/a	}
368	n/a	#endif
369	n/a	else
370	n/a	ecif.rvalue = rvalue;
371	n/a
372	n/a
373	n/a	switch (cif->abi)
374	n/a	{
375	n/a	#ifdef X86_WIN64
376	n/a	case FFI_WIN64:
377	n/a	ffi_call_win64(ffi_prep_args, &ecif, cif->bytes,
378	n/a	cif->flags, ecif.rvalue, fn);
379	n/a	break;
380	n/a	#elif defined(X86_WIN32)
381	n/a	case FFI_SYSV:
382	n/a	case FFI_MS_CDECL:
383	n/a	case FFI_STDCALL:
384	n/a	ffi_call_win32(ffi_prep_args, &ecif, cif->abi, cif->bytes, cif->flags,
385	n/a	ecif.rvalue, fn);
386	n/a	break;
387	n/a	case FFI_THISCALL:
388	n/a	case FFI_FASTCALL:
389	n/a	{
390	n/a	unsigned int abi = cif->abi;
391	n/a	unsigned int i, passed_regs = 0;
392	n/a
393	n/a	if (cif->flags == FFI_TYPE_STRUCT)
394	n/a	++passed_regs;
395	n/a
396	n/a	for (i=0; i < cif->nargs && passed_regs < 2;i++)
397	n/a	{
398	n/a	size_t sz;
399	n/a
400	n/a	if (cif->arg_types[i]->type == FFI_TYPE_FLOAT
401	n/a	\|\| cif->arg_types[i]->type == FFI_TYPE_STRUCT)
402	n/a	continue;
403	n/a	sz = (cif->arg_types[i]->size + 3) & ~3;
404	n/a	if (sz == 0 \|\| sz > 4)
405	n/a	continue;
406	n/a	++passed_regs;
407	n/a	}
408	n/a	if (passed_regs < 2 && abi == FFI_FASTCALL)
409	n/a	abi = FFI_THISCALL;
410	n/a	if (passed_regs < 1 && abi == FFI_THISCALL)
411	n/a	abi = FFI_STDCALL;
412	n/a	ffi_call_win32(ffi_prep_args, &ecif, abi, cif->bytes, cif->flags,
413	n/a	ecif.rvalue, fn);
414	n/a	}
415	n/a	break;
416	n/a	#else
417	n/a	case FFI_SYSV:
418	n/a	ffi_call_SYSV(ffi_prep_args, &ecif, cif->bytes, cif->flags, ecif.rvalue,
419	n/a	fn);
420	n/a	break;
421	n/a	#endif
422	n/a	default:
423	n/a	FFI_ASSERT(0);
424	n/a	break;
425	n/a	}
426	n/a	}
427	n/a
428	n/a
429	n/a	/ private members /
430	n/a
431	n/a	/* The following __attribute__((regparm(1))) decorations will have no effect
432	n/a	on MSVC or SUNPRO_C -- standard conventions apply. */
433	n/a	static void ffi_prep_incoming_args_SYSV (char stack, void *ret,
434	n/a	void** args, ffi_cif* cif);
435	n/a	void FFI_HIDDEN ffi_closure_SYSV (ffi_closure *)
436	n/a	__attribute__ ((regparm(1)));
437	n/a	unsigned int FFI_HIDDEN ffi_closure_SYSV_inner (ffi_closure , void , void )
438	n/a	__attribute__ ((regparm(1)));
439	n/a	void FFI_HIDDEN ffi_closure_raw_SYSV (ffi_raw_closure *)
440	n/a	__attribute__ ((regparm(1)));
441	n/a	#ifdef X86_WIN32
442	n/a	void FFI_HIDDEN ffi_closure_raw_THISCALL (ffi_raw_closure *)
443	n/a	__attribute__ ((regparm(1)));
444	n/a	#endif
445	n/a	#ifndef X86_WIN64
446	n/a	void FFI_HIDDEN ffi_closure_STDCALL (ffi_closure *)
447	n/a	__attribute__ ((regparm(1)));
448	n/a	void FFI_HIDDEN ffi_closure_THISCALL (ffi_closure *)
449	n/a	__attribute__ ((regparm(1)));
450	n/a	void FFI_HIDDEN ffi_closure_FASTCALL (ffi_closure *)
451	n/a	__attribute__ ((regparm(1)));
452	n/a	#else
453	n/a	void FFI_HIDDEN ffi_closure_win64 (ffi_closure *);
454	n/a	#endif
455	n/a
456	n/a	/* This function is jumped to by the trampoline */
457	n/a
458	n/a	#ifdef X86_WIN64
459	n/a	void * FFI_HIDDEN
460	n/a	ffi_closure_win64_inner (ffi_closure closure, void args) {
461	n/a	ffi_cif *cif;
462	n/a	void **arg_area;
463	n/a	void *result;
464	n/a	void *resp = &result;
465	n/a
466	n/a	cif = closure->cif;
467	n/a	arg_area = (void*) alloca (cif->nargs sizeof (void*));
468	n/a
469	n/a	/* this call will initialize ARG_AREA, such that each
470	n/a	* element in that array points to the corresponding
471	n/a	* value on the stack; and if the function returns
472	n/a	* a structure, it will change RESP to point to the
473	n/a	* structure return address. */
474	n/a
475	n/a	ffi_prep_incoming_args_SYSV(args, &resp, arg_area, cif);
476	n/a
477	n/a	(closure->fun) (cif, resp, arg_area, closure->user_data);
478	n/a
479	n/a	/* The result is returned in rax. This does the right thing for
480	n/a	result types except for floats; we have to 'mov xmm0, rax' in the
481	n/a	caller to correct this.
482	n/a	TODO: structure sizes of 3 5 6 7 are returned by reference, too!!!
483	n/a	*/
484	n/a	return cif->rtype->size > sizeof(void ) ? resp : (void **)resp;
485	n/a	}
486	n/a
487	n/a	#else
488	n/a	unsigned int FFI_HIDDEN __attribute__ ((regparm(1)))
489	n/a	ffi_closure_SYSV_inner (ffi_closure closure, void respp, void args)
490	n/a	{
491	n/a	/* our various things... */
492	n/a	ffi_cif *cif;
493	n/a	void **arg_area;
494	n/a
495	n/a	cif = closure->cif;
496	n/a	arg_area = (void*) alloca (cif->nargs sizeof (void*));
497	n/a
498	n/a	/* this call will initialize ARG_AREA, such that each
499	n/a	* element in that array points to the corresponding
500	n/a	* value on the stack; and if the function returns
501	n/a	* a structure, it will change RESP to point to the
502	n/a	* structure return address. */
503	n/a
504	n/a	ffi_prep_incoming_args_SYSV(args, respp, arg_area, cif);
505	n/a
506	n/a	(closure->fun) (cif, *respp, arg_area, closure->user_data);
507	n/a
508	n/a	return cif->flags;
509	n/a	}
510	n/a	#endif /* !X86_WIN64 */
511	n/a
512	n/a	static void
513	n/a	ffi_prep_incoming_args_SYSV(char stack, void rvalue, void *avalue,
514	n/a	ffi_cif *cif)
515	n/a	{
516	n/a	register unsigned int i;
517	n/a	register void **p_argv;
518	n/a	register char *argp;
519	n/a	register ffi_type **p_arg;
520	n/a
521	n/a	argp = stack;
522	n/a
523	n/a	#ifdef X86_WIN64
524	n/a	if (cif->rtype->size > sizeof(ffi_arg)
525	n/a	\|\| (cif->flags == FFI_TYPE_STRUCT
526	n/a	&& (cif->rtype->size != 1 && cif->rtype->size != 2
527	n/a	&& cif->rtype->size != 4 && cif->rtype->size != 8))) {
528	n/a	rvalue = (void **) argp;
529	n/a	argp += sizeof(void *);
530	n/a	}
531	n/a	#else
532	n/a	if ( cif->flags == FFI_TYPE_STRUCT
533	n/a	\|\| cif->flags == FFI_TYPE_MS_STRUCT ) {
534	n/a	rvalue = (void **) argp;
535	n/a	argp += sizeof(void *);
536	n/a	}
537	n/a	#endif
538	n/a
539	n/a	p_argv = avalue;
540	n/a
541	n/a	for (i = cif->nargs, p_arg = cif->arg_types; (i != 0); i--, p_arg++)
542	n/a	{
543	n/a	size_t z;
544	n/a
545	n/a	/* Align if necessary */
546	n/a	if ((sizeof(void*) - 1) & (size_t) argp) {
547	n/a	argp = (char ) ALIGN(argp, sizeof(void));
548	n/a	}
549	n/a
550	n/a	#ifdef X86_WIN64
551	n/a	if ((*p_arg)->size > sizeof(ffi_arg)
552	n/a	\|\| ((*p_arg)->type == FFI_TYPE_STRUCT
553	n/a	&& ((p_arg)->size != 1 && (p_arg)->size != 2
554	n/a	&& (p_arg)->size != 4 && (p_arg)->size != 8)))
555	n/a	{
556	n/a	z = sizeof(void *);
557	n/a	p_argv = (void **)argp;
558	n/a	}
559	n/a	else
560	n/a	#endif
561	n/a	{
562	n/a	z = (*p_arg)->size;
563	n/a
564	n/a	/* because we're little endian, this is what it turns into. */
565	n/a
566	n/a	p_argv = (void) argp;
567	n/a	}
568	n/a
569	n/a	p_argv++;
570	n/a	#ifdef X86_WIN64
571	n/a	argp += (z + sizeof(void) - 1) & ~(sizeof(void) - 1);
572	n/a	#else
573	n/a	argp += z;
574	n/a	#endif
575	n/a	}
576	n/a
577	n/a	return;
578	n/a	}
579	n/a
580	n/a	#define FFI_INIT_TRAMPOLINE_WIN64(TRAMP,FUN,CTX,MASK) \
581	n/a	{ unsigned char __tramp = (unsigned char)(TRAMP); \
582	n/a	void* __fun = (void*)(FUN); \
583	n/a	void* __ctx = (void*)(CTX); \
584	n/a	(unsigned char) &__tramp[0] = 0x41; \
585	n/a	(unsigned char) &__tramp[1] = 0xbb; \
586	n/a	(unsigned int) &__tramp[2] = MASK; /* mov $mask, %r11 */ \
587	n/a	(unsigned char) &__tramp[6] = 0x48; \
588	n/a	(unsigned char) &__tramp[7] = 0xb8; \
589	n/a	(void) &__tramp[8] = __ctx; / mov __ctx, %rax */ \
590	n/a	(unsigned char ) &__tramp[16] = 0x49; \
591	n/a	(unsigned char ) &__tramp[17] = 0xba; \
592	n/a	(void) &__tramp[18] = __fun; / mov __fun, %r10 */ \
593	n/a	(unsigned char ) &__tramp[26] = 0x41; \
594	n/a	(unsigned char ) &__tramp[27] = 0xff; \
595	n/a	(unsigned char ) &__tramp[28] = 0xe2; /* jmp %r10 */ \
596	n/a	}
597	n/a
598	n/a	/* How to make a trampoline. Derived from gcc/config/i386/i386.c. */
599	n/a
600	n/a	#define FFI_INIT_TRAMPOLINE(TRAMP,FUN,CTX) \
601	n/a	{ unsigned char __tramp = (unsigned char)(TRAMP); \
602	n/a	unsigned int __fun = (unsigned int)(FUN); \
603	n/a	unsigned int __ctx = (unsigned int)(CTX); \
604	n/a	unsigned int __dis = __fun - (__ctx + 10); \
605	n/a	(unsigned char) &__tramp[0] = 0xb8; \
606	n/a	(unsigned int) &__tramp[1] = __ctx; /* movl __ctx, %eax */ \
607	n/a	(unsigned char ) &__tramp[5] = 0xe9; \
608	n/a	(unsigned int) &__tramp[6] = __dis; /* jmp __fun */ \
609	n/a	}
610	n/a
611	n/a	#define FFI_INIT_TRAMPOLINE_RAW_THISCALL(TRAMP,FUN,CTX,SIZE) \
612	n/a	{ unsigned char __tramp = (unsigned char)(TRAMP); \
613	n/a	unsigned int __fun = (unsigned int)(FUN); \
614	n/a	unsigned int __ctx = (unsigned int)(CTX); \
615	n/a	unsigned int __dis = __fun - (__ctx + 49); \
616	n/a	unsigned short __size = (unsigned short)(SIZE); \
617	n/a	(unsigned int ) &__tramp[0] = 0x8324048b; /* mov (%esp), %eax */ \
618	n/a	(unsigned int ) &__tramp[4] = 0x4c890cec; /* sub $12, %esp */ \
619	n/a	(unsigned int ) &__tramp[8] = 0x04890424; /* mov %ecx, 4(%esp) */ \
620	n/a	(unsigned char) &__tramp[12] = 0x24; /* mov %eax, (%esp) */ \
621	n/a	(unsigned char) &__tramp[13] = 0xb8; \
622	n/a	(unsigned int ) &__tramp[14] = __size; /* mov __size, %eax */ \
623	n/a	(unsigned int ) &__tramp[18] = 0x08244c8d; /* lea 8(%esp), %ecx */ \
624	n/a	(unsigned int ) &__tramp[22] = 0x4802e8c1; /* shr $2, %eax ; dec %eax */ \
625	n/a	(unsigned short) &__tramp[26] = 0x0b74; /* jz 1f */ \
626	n/a	(unsigned int ) &__tramp[28] = 0x8908518b; /* 2b: mov 8(%ecx), %edx */ \
627	n/a	(unsigned int ) &__tramp[32] = 0x04c18311; /* mov %edx, (%ecx) ; add $4, %ecx */ \
628	n/a	(unsigned char) &__tramp[36] = 0x48; /* dec %eax */ \
629	n/a	(unsigned short) &__tramp[37] = 0xf575; /* jnz 2b ; 1f: */ \
630	n/a	(unsigned char) &__tramp[39] = 0xb8; \
631	n/a	(unsigned int) &__tramp[40] = __ctx; /* movl __ctx, %eax */ \
632	n/a	(unsigned char ) &__tramp[44] = 0xe8; \
633	n/a	(unsigned int) &__tramp[45] = __dis; /* call __fun */ \
634	n/a	(unsigned char) &__tramp[49] = 0xc2; /* ret */ \
635	n/a	(unsigned short) &__tramp[50] = (__size + 8); /* ret (__size + 8) */ \
636	n/a	}
637	n/a
638	n/a	#define FFI_INIT_TRAMPOLINE_STDCALL(TRAMP,FUN,CTX) \
639	n/a	{ unsigned char __tramp = (unsigned char)(TRAMP); \
640	n/a	unsigned int __fun = (unsigned int)(FUN); \
641	n/a	unsigned int __ctx = (unsigned int)(CTX); \
642	n/a	unsigned int __dis = __fun - (__ctx + 10); \
643	n/a	(unsigned char) &__tramp[0] = 0xb8; \
644	n/a	(unsigned int) &__tramp[1] = __ctx; /* movl __ctx, %eax */ \
645	n/a	(unsigned char ) &__tramp[5] = 0xe8; \
646	n/a	(unsigned int) &__tramp[6] = __dis; /* call __fun */ \
647	n/a	}
648	n/a
649	n/a	/* the cif must already be prep'ed */
650	n/a
651	n/a	ffi_status
652	n/a	ffi_prep_closure_loc (ffi_closure* closure,
653	n/a	ffi_cif* cif,
654	n/a	void (fun)(ffi_cif,void,void,void),
655	n/a	void *user_data,
656	n/a	void *codeloc)
657	n/a	{
658	n/a	#ifdef X86_WIN64
659	n/a	#define ISFLOAT(IDX) (cif->arg_types[IDX]->type == FFI_TYPE_FLOAT \|\| cif->arg_types[IDX]->type == FFI_TYPE_DOUBLE)
660	n/a	#define FLAG(IDX) (cif->nargs>(IDX)&&ISFLOAT(IDX)?(1<<(IDX)):0)
661	n/a	if (cif->abi == FFI_WIN64)
662	n/a	{
663	n/a	int mask = FLAG(0)\|FLAG(1)\|FLAG(2)\|FLAG(3);
664	n/a	FFI_INIT_TRAMPOLINE_WIN64 (&closure->tramp[0],
665	n/a	&ffi_closure_win64,
666	n/a	codeloc, mask);
667	n/a	/* make sure we can execute here */
668	n/a	}
669	n/a	#else
670	n/a	if (cif->abi == FFI_SYSV)
671	n/a	{
672	n/a	FFI_INIT_TRAMPOLINE (&closure->tramp[0],
673	n/a	&ffi_closure_SYSV,
674	n/a	(void*)codeloc);
675	n/a	}
676	n/a	else if (cif->abi == FFI_FASTCALL)
677	n/a	{
678	n/a	FFI_INIT_TRAMPOLINE_STDCALL (&closure->tramp[0],
679	n/a	&ffi_closure_FASTCALL,
680	n/a	(void*)codeloc);
681	n/a	}
682	n/a	else if (cif->abi == FFI_THISCALL)
683	n/a	{
684	n/a	FFI_INIT_TRAMPOLINE_STDCALL (&closure->tramp[0],
685	n/a	&ffi_closure_THISCALL,
686	n/a	(void*)codeloc);
687	n/a	}
688	n/a	else if (cif->abi == FFI_STDCALL)
689	n/a	{
690	n/a	FFI_INIT_TRAMPOLINE_STDCALL (&closure->tramp[0],
691	n/a	&ffi_closure_STDCALL,
692	n/a	(void*)codeloc);
693	n/a	}
694	n/a	#ifdef X86_WIN32
695	n/a	else if (cif->abi == FFI_MS_CDECL)
696	n/a	{
697	n/a	FFI_INIT_TRAMPOLINE (&closure->tramp[0],
698	n/a	&ffi_closure_SYSV,
699	n/a	(void*)codeloc);
700	n/a	}
701	n/a	#endif /* X86_WIN32 */
702	n/a	#endif /* !X86_WIN64 */
703	n/a	else
704	n/a	{
705	n/a	return FFI_BAD_ABI;
706	n/a	}
707	n/a
708	n/a	closure->cif = cif;
709	n/a	closure->user_data = user_data;
710	n/a	closure->fun = fun;
711	n/a
712	n/a	return FFI_OK;
713	n/a	}
714	n/a
715	n/a	/* ------- Native raw API support -------------------------------- */
716	n/a
717	n/a	#if !FFI_NO_RAW_API
718	n/a
719	n/a	ffi_status
720	n/a	ffi_prep_raw_closure_loc (ffi_raw_closure* closure,
721	n/a	ffi_cif* cif,
722	n/a	void (fun)(ffi_cif,void,ffi_raw,void*),
723	n/a	void *user_data,
724	n/a	void *codeloc)
725	n/a	{
726	n/a	int i;
727	n/a
728	n/a	if (cif->abi != FFI_SYSV
729	n/a	#ifdef X86_WIN32
730	n/a	&& cif->abi != FFI_THISCALL
731	n/a	#endif
732	n/a	)
733	n/a	return FFI_BAD_ABI;
734	n/a
735	n/a	/* we currently don't support certain kinds of arguments for raw
736	n/a	closures. This should be implemented by a separate assembly
737	n/a	language routine, since it would require argument processing,
738	n/a	something we don't do now for performance. */
739	n/a
740	n/a	for (i = cif->nargs-1; i >= 0; i--)
741	n/a	{
742	n/a	FFI_ASSERT (cif->arg_types[i]->type != FFI_TYPE_STRUCT);
743	n/a	FFI_ASSERT (cif->arg_types[i]->type != FFI_TYPE_LONGDOUBLE);
744	n/a	}
745	n/a
746	n/a	#ifdef X86_WIN32
747	n/a	if (cif->abi == FFI_SYSV)
748	n/a	{
749	n/a	#endif
750	n/a	FFI_INIT_TRAMPOLINE (&closure->tramp[0], &ffi_closure_raw_SYSV,
751	n/a	codeloc);
752	n/a	#ifdef X86_WIN32
753	n/a	}
754	n/a	else if (cif->abi == FFI_THISCALL)
755	n/a	{
756	n/a	FFI_INIT_TRAMPOLINE_RAW_THISCALL (&closure->tramp[0], &ffi_closure_raw_THISCALL, codeloc, cif->bytes);
757	n/a	}
758	n/a	#endif
759	n/a	closure->cif = cif;
760	n/a	closure->user_data = user_data;
761	n/a	closure->fun = fun;
762	n/a
763	n/a	return FFI_OK;
764	n/a	}
765	n/a
766	n/a	static void
767	n/a	ffi_prep_args_raw(char stack, extended_cif ecif)
768	n/a	{
769	n/a	memcpy (stack, ecif->avalue, ecif->cif->bytes);
770	n/a	}
771	n/a
772	n/a	/* we borrow this routine from libffi (it must be changed, though, to
773	n/a	* actually call the function passed in the first argument. as of
774	n/a	* libffi-1.20, this is not the case.)
775	n/a	*/
776	n/a
777	n/a	void
778	n/a	ffi_raw_call(ffi_cif cif, void (fn)(void), void rvalue, ffi_raw fake_avalue)
779	n/a	{
780	n/a	extended_cif ecif;
781	n/a	void avalue = (void )fake_avalue;
782	n/a
783	n/a	ecif.cif = cif;
784	n/a	ecif.avalue = avalue;
785	n/a
786	n/a	/* If the return value is a struct and we don't have a return */
787	n/a	/* value address then we need to make one */
788	n/a
789	n/a	#ifdef X86_WIN64
790	n/a	if (rvalue == NULL
791	n/a	&& cif->flags == FFI_TYPE_STRUCT
792	n/a	&& cif->rtype->size != 1 && cif->rtype->size != 2
793	n/a	&& cif->rtype->size != 4 && cif->rtype->size != 8)
794	n/a	{
795	n/a	ecif.rvalue = alloca((cif->rtype->size + 0xF) & ~0xF);
796	n/a	}
797	n/a	#else
798	n/a	if (rvalue == NULL
799	n/a	&& (cif->flags == FFI_TYPE_STRUCT
800	n/a	\|\| cif->flags == FFI_TYPE_MS_STRUCT))
801	n/a	{
802	n/a	ecif.rvalue = alloca(cif->rtype->size);
803	n/a	}
804	n/a	#endif
805	n/a	else
806	n/a	ecif.rvalue = rvalue;
807	n/a
808	n/a
809	n/a	switch (cif->abi)
810	n/a	{
811	n/a	#ifdef X86_WIN64
812	n/a	case FFI_WIN64:
813	n/a	ffi_call_win64(ffi_prep_args_raw, &ecif, cif->bytes,
814	n/a	cif->flags, ecif.rvalue, fn);
815	n/a	break;
816	n/a	#elif defined(X86_WIN32)
817	n/a	case FFI_SYSV:
818	n/a	case FFI_MS_CDECL:
819	n/a	case FFI_STDCALL:
820	n/a	ffi_call_win32(ffi_prep_args_raw, &ecif, cif->abi, cif->bytes, cif->flags,
821	n/a	ecif.rvalue, fn);
822	n/a	break;
823	n/a	case FFI_THISCALL:
824	n/a	case FFI_FASTCALL:
825	n/a	{
826	n/a	unsigned int abi = cif->abi;
827	n/a	unsigned int i, passed_regs = 0;
828	n/a
829	n/a	if (cif->flags == FFI_TYPE_STRUCT)
830	n/a	++passed_regs;
831	n/a
832	n/a	for (i=0; i < cif->nargs && passed_regs < 2;i++)
833	n/a	{
834	n/a	size_t sz;
835	n/a
836	n/a	if (cif->arg_types[i]->type == FFI_TYPE_FLOAT
837	n/a	\|\| cif->arg_types[i]->type == FFI_TYPE_STRUCT)
838	n/a	continue;
839	n/a	sz = (cif->arg_types[i]->size + 3) & ~3;
840	n/a	if (sz == 0 \|\| sz > 4)
841	n/a	continue;
842	n/a	++passed_regs;
843	n/a	}
844	n/a	if (passed_regs < 2 && abi == FFI_FASTCALL)
845	n/a	abi = FFI_THISCALL;
846	n/a	if (passed_regs < 1 && abi == FFI_THISCALL)
847	n/a	abi = FFI_STDCALL;
848	n/a	ffi_call_win32(ffi_prep_args_raw, &ecif, abi, cif->bytes, cif->flags,
849	n/a	ecif.rvalue, fn);
850	n/a	}
851	n/a	break;
852	n/a	#else
853	n/a	case FFI_SYSV:
854	n/a	ffi_call_SYSV(ffi_prep_args_raw, &ecif, cif->bytes, cif->flags, ecif.rvalue,
855	n/a	fn);
856	n/a	break;
857	n/a	#endif
858	n/a	default:
859	n/a	FFI_ASSERT(0);
860	n/a	break;
861	n/a	}
862	n/a	}
863	n/a
864	n/a	#endif
865	n/a
866	n/a	#endif /* !__x86_64__ \|\| X86_WIN64 */
867	n/a