1 /* -----------------------------------------------------------------------
2 ffi.c - Copyright (c) 1996, 1998, 1999, 2001 Red Hat, Inc.
3 Copyright (c) 2002 Ranjit Mathew
4 Copyright (c) 2002 Bo Thorsen
5 Copyright (c) 2002 Roger Sayle
7 x86 Foreign Function Interface
9 Permission is hereby granted, free of charge, to any person obtaining
10 a copy of this software and associated documentation files (the
11 ``Software''), to deal in the Software without restriction, including
12 without limitation the rights to use, copy, modify, merge, publish,
13 distribute, sublicense, and/or sell copies of the Software, and to
14 permit persons to whom the Software is furnished to do so, subject to
15 the following conditions:
17 The above copyright notice and this permission notice shall be included
18 in all copies or substantial portions of the Software.
20 THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, EXPRESS
21 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
22 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
23 IN NO EVENT SHALL CYGNUS SOLUTIONS BE LIABLE FOR ANY CLAIM, DAMAGES OR
24 OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
25 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
26 OTHER DEALINGS IN THE SOFTWARE.
27 ----------------------------------------------------------------------- */
32 #include <ffi_common.h>
36 /* ffi_prep_args is called by the assembly routine once stack space
37 has been allocated for the function's arguments */
40 void ffi_prep_args(char *stack
, extended_cif
*ecif
)
43 register unsigned int i
;
44 register void **p_argv
;
46 register ffi_type
**p_arg
;
50 if (ecif
->cif
->flags
== FFI_TYPE_STRUCT
)
52 *(void **) argp
= ecif
->rvalue
;
56 p_argv
= ecif
->avalue
;
58 for (i
= ecif
->cif
->nargs
, p_arg
= ecif
->cif
->arg_types
;
64 /* Align if necessary */
65 if ((sizeof(int) - 1) & (unsigned) argp
)
66 argp
= (char *) ALIGN(argp
, sizeof(int));
72 switch ((*p_arg
)->type
)
75 *(signed int *) argp
= (signed int)*(SINT8
*)(* p_argv
);
79 *(unsigned int *) argp
= (unsigned int)*(UINT8
*)(* p_argv
);
83 *(signed int *) argp
= (signed int)*(SINT16
*)(* p_argv
);
87 *(unsigned int *) argp
= (unsigned int)*(UINT16
*)(* p_argv
);
91 *(signed int *) argp
= (signed int)*(SINT32
*)(* p_argv
);
95 *(unsigned int *) argp
= (unsigned int)*(UINT32
*)(* p_argv
);
99 *(unsigned int *) argp
= (unsigned int)*(UINT32
*)(* p_argv
);
108 memcpy(argp
, *p_argv
, z
);
117 /* Perform machine dependent cif processing */
118 ffi_status
ffi_prep_cif_machdep(ffi_cif
*cif
)
120 /* Set the return type flag */
121 switch (cif
->rtype
->type
)
125 case FFI_TYPE_STRUCT
:
127 case FFI_TYPE_SINT64
:
129 case FFI_TYPE_DOUBLE
:
130 case FFI_TYPE_LONGDOUBLE
:
131 cif
->flags
= (unsigned) cif
->rtype
->type
;
134 case FFI_TYPE_UINT64
:
135 cif
->flags
= FFI_TYPE_SINT64
;
139 case FFI_TYPE_STRUCT
:
140 if (cif
->rtype
->size
== 1)
142 cif
->flags
= FFI_TYPE_SINT8
; /* same as char size */
144 else if (cif
->rtype
->size
== 2)
146 cif
->flags
= FFI_TYPE_SINT16
; /* same as short size */
148 else if (cif
->rtype
->size
== 4)
150 cif
->flags
= FFI_TYPE_INT
; /* same as int type */
152 else if (cif
->rtype
->size
== 8)
154 cif
->flags
= FFI_TYPE_SINT64
; /* same as int64 type */
158 cif
->flags
= FFI_TYPE_STRUCT
;
164 cif
->flags
= FFI_TYPE_INT
;
173 extern void ffi_call_SYSV(void (*)(char *, extended_cif
*),
174 /*@out@*/ extended_cif
*,
176 /*@out@*/ unsigned *,
184 extern void ffi_call_STDCALL(void (*)(char *, extended_cif
*),
185 /*@out@*/ extended_cif
*,
187 /*@out@*/ unsigned *,
191 #endif /* X86_WIN32 */
193 void ffi_call(/*@dependent@*/ ffi_cif
*cif
,
195 /*@out@*/ void *rvalue
,
196 /*@dependent@*/ void **avalue
)
201 ecif
.avalue
= avalue
;
203 /* If the return value is a struct and we don't have a return */
204 /* value address then we need to make one */
206 if ((rvalue
== NULL
) &&
207 (cif
->flags
== FFI_TYPE_STRUCT
))
210 ecif
.rvalue
= alloca(cif
->rtype
->size
);
214 ecif
.rvalue
= rvalue
;
221 ffi_call_SYSV(ffi_prep_args
, &ecif
, cif
->bytes
,
222 cif
->flags
, ecif
.rvalue
, fn
);
228 ffi_call_STDCALL(ffi_prep_args
, &ecif
, cif
->bytes
,
229 cif
->flags
, ecif
.rvalue
, fn
);
232 #endif /* X86_WIN32 */
240 /** private members **/
242 static void ffi_prep_incoming_args_SYSV (char *stack
, void **ret
,
243 void** args
, ffi_cif
* cif
);
244 void FFI_HIDDEN
ffi_closure_SYSV (ffi_closure
*)
245 __attribute__ ((regparm(1)));
246 unsigned int FFI_HIDDEN
ffi_closure_SYSV_inner (ffi_closure
*, void **, void *)
247 __attribute__ ((regparm(1)));
248 void FFI_HIDDEN
ffi_closure_raw_SYSV (ffi_raw_closure
*)
249 __attribute__ ((regparm(1)));
251 /* This function is jumped to by the trampoline */
253 unsigned int FFI_HIDDEN
254 ffi_closure_SYSV_inner (closure
, respp
, args
)
255 ffi_closure
*closure
;
259 // our various things...
264 arg_area
= (void**) alloca (cif
->nargs
* sizeof (void*));
266 /* this call will initialize ARG_AREA, such that each
267 * element in that array points to the corresponding
268 * value on the stack; and if the function returns
269 * a structure, it will re-set RESP to point to the
270 * structure return address. */
272 ffi_prep_incoming_args_SYSV(args
, respp
, arg_area
, cif
);
274 (closure
->fun
) (cif
, *respp
, arg_area
, closure
->user_data
);
281 ffi_prep_incoming_args_SYSV(char *stack
, void **rvalue
,
282 void **avalue
, ffi_cif
*cif
)
285 register unsigned int i
;
286 register void **p_argv
;
288 register ffi_type
**p_arg
;
292 if ( cif
->flags
== FFI_TYPE_STRUCT
) {
293 *rvalue
= *(void **) argp
;
299 for (i
= cif
->nargs
, p_arg
= cif
->arg_types
; (i
!= 0); i
--, p_arg
++)
303 /* Align if necessary */
304 if ((sizeof(int) - 1) & (unsigned) argp
) {
305 argp
= (char *) ALIGN(argp
, sizeof(int));
310 /* because we're little endian, this is what it turns into. */
312 *p_argv
= (void*) argp
;
321 /* How to make a trampoline. Derived from gcc/config/i386/i386.c. */
323 #define FFI_INIT_TRAMPOLINE(TRAMP,FUN,CTX) \
324 ({ unsigned char *__tramp = (unsigned char*)(TRAMP); \
325 unsigned int __fun = (unsigned int)(FUN); \
326 unsigned int __ctx = (unsigned int)(CTX); \
327 unsigned int __dis = __fun - ((unsigned int) __tramp + FFI_TRAMPOLINE_SIZE); \
328 *(unsigned char*) &__tramp[0] = 0xb8; \
329 *(unsigned int*) &__tramp[1] = __ctx; /* movl __ctx, %eax */ \
330 *(unsigned char *) &__tramp[5] = 0xe9; \
331 *(unsigned int*) &__tramp[6] = __dis; /* jmp __fun */ \
335 /* the cif must already be prep'ed */
338 ffi_prep_closure (ffi_closure
* closure
,
340 void (*fun
)(ffi_cif
*,void*,void**,void*),
343 FFI_ASSERT (cif
->abi
== FFI_SYSV
);
345 FFI_INIT_TRAMPOLINE (&closure
->tramp
[0], \
350 closure
->user_data
= user_data
;
356 /* ------- Native raw API support -------------------------------- */
361 ffi_prep_raw_closure (ffi_raw_closure
* closure
,
363 void (*fun
)(ffi_cif
*,void*,ffi_raw
*,void*),
368 FFI_ASSERT (cif
->abi
== FFI_SYSV
);
370 // we currently don't support certain kinds of arguments for raw
371 // closures. This should be implemented by a separate assembly language
372 // routine, since it would require argument processing, something we
373 // don't do now for performance.
375 for (i
= cif
->nargs
-1; i
>= 0; i
--)
377 FFI_ASSERT (cif
->arg_types
[i
]->type
!= FFI_TYPE_STRUCT
);
378 FFI_ASSERT (cif
->arg_types
[i
]->type
!= FFI_TYPE_LONGDOUBLE
);
382 FFI_INIT_TRAMPOLINE (&closure
->tramp
[0], &ffi_closure_raw_SYSV
,
386 closure
->user_data
= user_data
;
393 ffi_prep_args_raw(char *stack
, extended_cif
*ecif
)
395 memcpy (stack
, ecif
->avalue
, ecif
->cif
->bytes
);
398 /* we borrow this routine from libffi (it must be changed, though, to
399 * actually call the function passed in the first argument. as of
400 * libffi-1.20, this is not the case.)
404 ffi_call_SYSV(void (*)(char *, extended_cif
*),
405 /*@out@*/ extended_cif
*,
407 /*@out@*/ unsigned *,
412 ffi_call_STDCALL(void (*)(char *, extended_cif
*),
413 /*@out@*/ extended_cif
*,
415 /*@out@*/ unsigned *,
417 #endif /* X86_WIN32 */
420 ffi_raw_call(/*@dependent@*/ ffi_cif
*cif
,
422 /*@out@*/ void *rvalue
,
423 /*@dependent@*/ ffi_raw
*fake_avalue
)
426 void **avalue
= (void **)fake_avalue
;
429 ecif
.avalue
= avalue
;
431 /* If the return value is a struct and we don't have a return */
432 /* value address then we need to make one */
434 if ((rvalue
== NULL
) &&
435 (cif
->rtype
->type
== FFI_TYPE_STRUCT
))
438 ecif
.rvalue
= alloca(cif
->rtype
->size
);
442 ecif
.rvalue
= rvalue
;
449 ffi_call_SYSV(ffi_prep_args_raw
, &ecif
, cif
->bytes
,
450 cif
->flags
, ecif
.rvalue
, fn
);
456 ffi_call_STDCALL(ffi_prep_args_raw
, &ecif
, cif
->bytes
,
457 cif
->flags
, ecif
.rvalue
, fn
);
460 #endif /* X86_WIN32 */
469 #endif /* __x86_64__ */