added libffi for win support
This commit is contained in:
Araq
parent
3d869d4dec
commit
e2a4d591e5
22 changed files with 7192 additions and 10 deletions
457
lib/wrappers/libffi/msvc/ffi.c
Normal file
457
lib/wrappers/libffi/msvc/ffi.c
Normal file
|
|
@ -0,0 +1,457 @@
|
|||
/* -----------------------------------------------------------------------
|
||||
ffi.c - Copyright (c) 1996, 1998, 1999, 2001 Red Hat, Inc.
|
||||
Copyright (c) 2002 Ranjit Mathew
|
||||
Copyright (c) 2002 Bo Thorsen
|
||||
Copyright (c) 2002 Roger Sayle
|
||||
|
||||
x86 Foreign Function Interface
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining
|
||||
a copy of this software and associated documentation files (the
|
||||
``Software''), to deal in the Software without restriction, including
|
||||
without limitation the rights to use, copy, modify, merge, publish,
|
||||
distribute, sublicense, and/or sell copies of the Software, and to
|
||||
permit persons to whom the Software is furnished to do so, subject to
|
||||
the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included
|
||||
in all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||||
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
IN NO EVENT SHALL CYGNUS SOLUTIONS BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
||||
OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
||||
OTHER DEALINGS IN THE SOFTWARE.
|
||||
----------------------------------------------------------------------- */
|
||||
|
||||
#include <ffi.h>
|
||||
#include <ffi_common.h>
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
/* ffi_prep_args is called by the assembly routine once stack space
|
||||
has been allocated for the function's arguments */
|
||||
|
||||
extern void Py_FatalError(const char *msg);
|
||||
|
||||
/*@-exportheader@*/
|
||||
void ffi_prep_args(char *stack, extended_cif *ecif)
|
||||
/*@=exportheader@*/
|
||||
{
|
||||
register unsigned int i;
|
||||
register void **p_argv;
|
||||
register char *argp;
|
||||
register ffi_type **p_arg;
|
||||
|
||||
argp = stack;
|
||||
if (ecif->cif->rtype->type == FFI_TYPE_STRUCT)
|
||||
{
|
||||
*(void **) argp = ecif->rvalue;
|
||||
argp += sizeof(void *);
|
||||
}
|
||||
|
||||
p_argv = ecif->avalue;
|
||||
|
||||
for (i = ecif->cif->nargs, p_arg = ecif->cif->arg_types;
|
||||
i != 0;
|
||||
i--, p_arg++)
|
||||
{
|
||||
size_t z;
|
||||
|
||||
/* Align if necessary */
|
||||
if ((sizeof(void *) - 1) & (size_t) argp)
|
||||
argp = (char *) ALIGN(argp, sizeof(void *));
|
||||
|
||||
z = (*p_arg)->size;
|
||||
if (z < sizeof(int))
|
||||
{
|
||||
z = sizeof(int);
|
||||
switch ((*p_arg)->type)
|
||||
{
|
||||
case FFI_TYPE_SINT8:
|
||||
*(signed int *) argp = (signed int)*(SINT8 *)(* p_argv);
|
||||
break;
|
||||
|
||||
case FFI_TYPE_UINT8:
|
||||
*(unsigned int *) argp = (unsigned int)*(UINT8 *)(* p_argv);
|
||||
break;
|
||||
|
||||
case FFI_TYPE_SINT16:
|
||||
*(signed int *) argp = (signed int)*(SINT16 *)(* p_argv);
|
||||
break;
|
||||
|
||||
case FFI_TYPE_UINT16:
|
||||
*(unsigned int *) argp = (unsigned int)*(UINT16 *)(* p_argv);
|
||||
break;
|
||||
|
||||
case FFI_TYPE_SINT32:
|
||||
*(signed int *) argp = (signed int)*(SINT32 *)(* p_argv);
|
||||
break;
|
||||
|
||||
case FFI_TYPE_UINT32:
|
||||
*(unsigned int *) argp = (unsigned int)*(UINT32 *)(* p_argv);
|
||||
break;
|
||||
|
||||
case FFI_TYPE_STRUCT:
|
||||
*(unsigned int *) argp = (unsigned int)*(UINT32 *)(* p_argv);
|
||||
break;
|
||||
|
||||
default:
|
||||
FFI_ASSERT(0);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
memcpy(argp, *p_argv, z);
|
||||
}
|
||||
p_argv++;
|
||||
argp += z;
|
||||
}
|
||||
|
||||
if (argp >= stack && (unsigned)(argp - stack) > ecif->cif->bytes)
|
||||
{
|
||||
Py_FatalError("FFI BUG: not enough stack space for arguments");
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
/* Perform machine dependent cif processing */
|
||||
ffi_status ffi_prep_cif_machdep(ffi_cif *cif)
|
||||
{
|
||||
/* Set the return type flag */
|
||||
switch (cif->rtype->type)
|
||||
{
|
||||
case FFI_TYPE_VOID:
|
||||
case FFI_TYPE_STRUCT:
|
||||
case FFI_TYPE_SINT64:
|
||||
case FFI_TYPE_FLOAT:
|
||||
case FFI_TYPE_DOUBLE:
|
||||
case FFI_TYPE_LONGDOUBLE:
|
||||
cif->flags = (unsigned) cif->rtype->type;
|
||||
break;
|
||||
|
||||
case FFI_TYPE_UINT64:
|
||||
#ifdef _WIN64
|
||||
case FFI_TYPE_POINTER:
|
||||
#endif
|
||||
cif->flags = FFI_TYPE_SINT64;
|
||||
break;
|
||||
|
||||
default:
|
||||
cif->flags = FFI_TYPE_INT;
|
||||
break;
|
||||
}
|
||||
|
||||
return FFI_OK;
|
||||
}
|
||||
|
||||
#ifdef _WIN32
|
||||
extern int
|
||||
ffi_call_x86(void (*)(char *, extended_cif *),
|
||||
/*@out@*/ extended_cif *,
|
||||
unsigned, unsigned,
|
||||
/*@out@*/ unsigned *,
|
||||
void (*fn)());
|
||||
#endif
|
||||
|
||||
#ifdef _WIN64
|
||||
extern int
|
||||
ffi_call_AMD64(void (*)(char *, extended_cif *),
|
||||
/*@out@*/ extended_cif *,
|
||||
unsigned, unsigned,
|
||||
/*@out@*/ unsigned *,
|
||||
void (*fn)());
|
||||
#endif
|
||||
|
||||
int
|
||||
ffi_call(/*@dependent@*/ ffi_cif *cif,
|
||||
void (*fn)(),
|
||||
/*@out@*/ void *rvalue,
|
||||
/*@dependent@*/ void **avalue)
|
||||
{
|
||||
extended_cif ecif;
|
||||
|
||||
ecif.cif = cif;
|
||||
ecif.avalue = avalue;
|
||||
|
||||
/* If the return value is a struct and we don't have a return */
|
||||
/* value address then we need to make one */
|
||||
|
||||
if ((rvalue == NULL) &&
|
||||
(cif->rtype->type == FFI_TYPE_STRUCT))
|
||||
{
|
||||
/*@-sysunrecog@*/
|
||||
ecif.rvalue = alloca(cif->rtype->size);
|
||||
/*@=sysunrecog@*/
|
||||
}
|
||||
else
|
||||
ecif.rvalue = rvalue;
|
||||
|
||||
|
||||
switch (cif->abi)
|
||||
{
|
||||
#if !defined(_WIN64)
|
||||
case FFI_SYSV:
|
||||
case FFI_STDCALL:
|
||||
return ffi_call_x86(ffi_prep_args, &ecif, cif->bytes,
|
||||
cif->flags, ecif.rvalue, fn);
|
||||
break;
|
||||
#else
|
||||
case FFI_SYSV:
|
||||
/*@-usedef@*/
|
||||
/* Function call needs at least 40 bytes stack size, on win64 AMD64 */
|
||||
return ffi_call_AMD64(ffi_prep_args, &ecif, cif->bytes ? cif->bytes : 40,
|
||||
cif->flags, ecif.rvalue, fn);
|
||||
/*@=usedef@*/
|
||||
break;
|
||||
#endif
|
||||
|
||||
default:
|
||||
FFI_ASSERT(0);
|
||||
break;
|
||||
}
|
||||
return -1; /* theller: Hrm. */
|
||||
}
|
||||
|
||||
|
||||
/** private members **/
|
||||
|
||||
static void ffi_prep_incoming_args_SYSV (char *stack, void **ret,
|
||||
void** args, ffi_cif* cif);
|
||||
/* This function is jumped to by the trampoline */
|
||||
|
||||
#ifdef _WIN64
|
||||
void *
|
||||
#else
|
||||
static void __fastcall
|
||||
#endif
|
||||
ffi_closure_SYSV (ffi_closure *closure, int *argp)
|
||||
{
|
||||
// this is our return value storage
|
||||
long double res;
|
||||
|
||||
// our various things...
|
||||
ffi_cif *cif;
|
||||
void **arg_area;
|
||||
unsigned short rtype;
|
||||
void *resp = (void*)&res;
|
||||
void *args = &argp[1];
|
||||
|
||||
cif = closure->cif;
|
||||
arg_area = (void**) alloca (cif->nargs * sizeof (void*));
|
||||
|
||||
/* this call will initialize ARG_AREA, such that each
|
||||
* element in that array points to the corresponding
|
||||
* value on the stack; and if the function returns
|
||||
* a structure, it will re-set RESP to point to the
|
||||
* structure return address. */
|
||||
|
||||
ffi_prep_incoming_args_SYSV(args, (void**)&resp, arg_area, cif);
|
||||
|
||||
(closure->fun) (cif, resp, arg_area, closure->user_data);
|
||||
|
||||
rtype = cif->flags;
|
||||
|
||||
#if defined(_WIN32) && !defined(_WIN64)
|
||||
#ifdef _MSC_VER
|
||||
/* now, do a generic return based on the value of rtype */
|
||||
if (rtype == FFI_TYPE_INT)
|
||||
{
|
||||
_asm mov eax, resp ;
|
||||
_asm mov eax, [eax] ;
|
||||
}
|
||||
else if (rtype == FFI_TYPE_FLOAT)
|
||||
{
|
||||
_asm mov eax, resp ;
|
||||
_asm fld DWORD PTR [eax] ;
|
||||
// asm ("flds (%0)" : : "r" (resp) : "st" );
|
||||
}
|
||||
else if (rtype == FFI_TYPE_DOUBLE)
|
||||
{
|
||||
_asm mov eax, resp ;
|
||||
_asm fld QWORD PTR [eax] ;
|
||||
// asm ("fldl (%0)" : : "r" (resp) : "st", "st(1)" );
|
||||
}
|
||||
else if (rtype == FFI_TYPE_LONGDOUBLE)
|
||||
{
|
||||
// asm ("fldt (%0)" : : "r" (resp) : "st", "st(1)" );
|
||||
}
|
||||
else if (rtype == FFI_TYPE_SINT64)
|
||||
{
|
||||
_asm mov edx, resp ;
|
||||
_asm mov eax, [edx] ;
|
||||
_asm mov edx, [edx + 4] ;
|
||||
// asm ("movl 0(%0),%%eax;"
|
||||
// "movl 4(%0),%%edx"
|
||||
// : : "r"(resp)
|
||||
// : "eax", "edx");
|
||||
}
|
||||
#else
|
||||
/* now, do a generic return based on the value of rtype */
|
||||
if (rtype == FFI_TYPE_INT)
|
||||
{
|
||||
asm ("movl (%0),%%eax" : : "r" (resp) : "eax");
|
||||
}
|
||||
else if (rtype == FFI_TYPE_FLOAT)
|
||||
{
|
||||
asm ("flds (%0)" : : "r" (resp) : "st" );
|
||||
}
|
||||
else if (rtype == FFI_TYPE_DOUBLE)
|
||||
{
|
||||
asm ("fldl (%0)" : : "r" (resp) : "st", "st(1)" );
|
||||
}
|
||||
else if (rtype == FFI_TYPE_LONGDOUBLE)
|
||||
{
|
||||
asm ("fldt (%0)" : : "r" (resp) : "st", "st(1)" );
|
||||
}
|
||||
else if (rtype == FFI_TYPE_SINT64)
|
||||
{
|
||||
asm ("movl 0(%0),%%eax;"
|
||||
"movl 4(%0),%%edx"
|
||||
: : "r"(resp)
|
||||
: "eax", "edx");
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef _WIN64
|
||||
/* The result is returned in rax. This does the right thing for
|
||||
result types except for floats; we have to 'mov xmm0, rax' in the
|
||||
caller to correct this.
|
||||
*/
|
||||
return *(void **)resp;
|
||||
#endif
|
||||
}
|
||||
|
||||
/*@-exportheader@*/
|
||||
static void
|
||||
ffi_prep_incoming_args_SYSV(char *stack, void **rvalue,
|
||||
void **avalue, ffi_cif *cif)
|
||||
/*@=exportheader@*/
|
||||
{
|
||||
register unsigned int i;
|
||||
register void **p_argv;
|
||||
register char *argp;
|
||||
register ffi_type **p_arg;
|
||||
|
||||
argp = stack;
|
||||
|
||||
if ( cif->rtype->type == FFI_TYPE_STRUCT ) {
|
||||
*rvalue = *(void **) argp;
|
||||
argp += 4;
|
||||
}
|
||||
|
||||
p_argv = avalue;
|
||||
|
||||
for (i = cif->nargs, p_arg = cif->arg_types; (i != 0); i--, p_arg++)
|
||||
{
|
||||
size_t z;
|
||||
|
||||
/* Align if necessary */
|
||||
if ((sizeof(char *) - 1) & (size_t) argp) {
|
||||
argp = (char *) ALIGN(argp, sizeof(char*));
|
||||
}
|
||||
|
||||
z = (*p_arg)->size;
|
||||
|
||||
/* because we're little endian, this is what it turns into. */
|
||||
|
||||
*p_argv = (void*) argp;
|
||||
|
||||
p_argv++;
|
||||
argp += z;
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
/* the cif must already be prep'ed */
|
||||
extern void ffi_closure_OUTER();
|
||||
|
||||
ffi_status
|
||||
ffi_prep_closure_loc (ffi_closure* closure,
|
||||
ffi_cif* cif,
|
||||
void (*fun)(ffi_cif*,void*,void**,void*),
|
||||
void *user_data,
|
||||
void *codeloc)
|
||||
{
|
||||
short bytes;
|
||||
char *tramp;
|
||||
#ifdef _WIN64
|
||||
int mask = 0;
|
||||
#endif
|
||||
FFI_ASSERT (cif->abi == FFI_SYSV);
|
||||
|
||||
if (cif->abi == FFI_SYSV)
|
||||
bytes = 0;
|
||||
#if !defined(_WIN64)
|
||||
else if (cif->abi == FFI_STDCALL)
|
||||
bytes = cif->bytes;
|
||||
#endif
|
||||
else
|
||||
return FFI_BAD_ABI;
|
||||
|
||||
tramp = &closure->tramp[0];
|
||||
|
||||
#define BYTES(text) memcpy(tramp, text, sizeof(text)), tramp += sizeof(text)-1
|
||||
#define POINTER(x) *(void**)tramp = (void*)(x), tramp += sizeof(void*)
|
||||
#define SHORT(x) *(short*)tramp = x, tramp += sizeof(short)
|
||||
#define INT(x) *(int*)tramp = x, tramp += sizeof(int)
|
||||
|
||||
#ifdef _WIN64
|
||||
if (cif->nargs >= 1 &&
|
||||
(cif->arg_types[0]->type == FFI_TYPE_FLOAT
|
||||
|| cif->arg_types[0]->type == FFI_TYPE_DOUBLE))
|
||||
mask |= 1;
|
||||
if (cif->nargs >= 2 &&
|
||||
(cif->arg_types[1]->type == FFI_TYPE_FLOAT
|
||||
|| cif->arg_types[1]->type == FFI_TYPE_DOUBLE))
|
||||
mask |= 2;
|
||||
if (cif->nargs >= 3 &&
|
||||
(cif->arg_types[2]->type == FFI_TYPE_FLOAT
|
||||
|| cif->arg_types[2]->type == FFI_TYPE_DOUBLE))
|
||||
mask |= 4;
|
||||
if (cif->nargs >= 4 &&
|
||||
(cif->arg_types[3]->type == FFI_TYPE_FLOAT
|
||||
|| cif->arg_types[3]->type == FFI_TYPE_DOUBLE))
|
||||
mask |= 8;
|
||||
|
||||
/* 41 BB ---- mov r11d,mask */
|
||||
BYTES("\x41\xBB"); INT(mask);
|
||||
|
||||
/* 48 B8 -------- mov rax, closure */
|
||||
BYTES("\x48\xB8"); POINTER(closure);
|
||||
|
||||
/* 49 BA -------- mov r10, ffi_closure_OUTER */
|
||||
BYTES("\x49\xBA"); POINTER(ffi_closure_OUTER);
|
||||
|
||||
/* 41 FF E2 jmp r10 */
|
||||
BYTES("\x41\xFF\xE2");
|
||||
|
||||
#else
|
||||
|
||||
/* mov ecx, closure */
|
||||
BYTES("\xb9"); POINTER(closure);
|
||||
|
||||
/* mov edx, esp */
|
||||
BYTES("\x8b\xd4");
|
||||
|
||||
/* call ffi_closure_SYSV */
|
||||
BYTES("\xe8"); POINTER((char*)&ffi_closure_SYSV - (tramp + 4));
|
||||
|
||||
/* ret bytes */
|
||||
BYTES("\xc2");
|
||||
SHORT(bytes);
|
||||
|
||||
#endif
|
||||
|
||||
if (tramp - &closure->tramp[0] > FFI_TRAMPOLINE_SIZE)
|
||||
Py_FatalError("FFI_TRAMPOLINE_SIZE too small in " __FILE__);
|
||||
|
||||
closure->cif = cif;
|
||||
closure->user_data = user_data;
|
||||
closure->fun = fun;
|
||||
return FFI_OK;
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue