ag/cpython-source-deps
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Support for calling functions with PASCAL and REGISTER calling conventions on x86 Windows/Linux.

Browse Source 
Also changed indentation to be more consistent throughout the (adjusted) files.
This commit is contained in:
nielsAD
2014-08-23 00:18:47 +02:00
parent 1cee07be47
commit 098dca6b31
3 changed files with 611 additions and 598 deletions
Download Patch File Download Diff File Expand all files Collapse all files

209
src/x86/ffi.c
View File

@@ -43,19 +43,21 @@
/* ffi_prep_args is called by the assembly routine once stack space /* ffi_prep_args is called by the assembly routine once stack space
has been allocated for the function's arguments */ has been allocated for the function's arguments */
void ffi_prep_args(char *stack, extended_cif *ecif); unsigned int ffi_prep_args(char *stack, extended_cif *ecif);
void ffi_prep_args(char *stack, extended_cif *ecif) unsigned int ffi_prep_args(char *stack, extended_cif *ecif)
{ {
register unsigned int i; register unsigned int i;
register void **p_argv; register void **p_argv;
register char *argp; register char *argp;
register ffi_type **p_arg; register ffi_type **p_arg;
#ifndef X86_WIN64 #ifndef X86_WIN64
size_t p_stack_args[2]; void *p_stack_data[3];
void *p_stack_data[2];
char *argp2 = stack; char *argp2 = stack;
int stack_args_count = 0; unsigned int stack_args_count = 0;
int cabi = ecif->cif->abi; const int cabi = ecif->cif->abi;
const int dir = (cabi == FFI_PASCAL || cabi == FFI_REGISTER) ? -1 : +1;
#else
#define dir 1
#endif #endif
argp = stack; argp = stack;
@@ -63,18 +65,16 @@ void ffi_prep_args(char *stack, extended_cif *ecif)
if ((ecif->cif->flags == FFI_TYPE_STRUCT if ((ecif->cif->flags == FFI_TYPE_STRUCT
|| ecif->cif->flags == FFI_TYPE_MS_STRUCT) || ecif->cif->flags == FFI_TYPE_MS_STRUCT)
#ifdef X86_WIN64 #ifdef X86_WIN64
&& (ecif->cif->rtype->size != 1 && ecif->cif->rtype->size != 2 && ((ecif->cif->rtype->size & (1 | 2 | 4 | 8)) == 0)
&& ecif->cif->rtype->size != 4 && ecif->cif->rtype->size != 8)
#endif #endif
) )
{ {
*(void **) argp = ecif->rvalue; *(void **) argp = ecif->rvalue;
#ifndef X86_WIN64 #ifndef X86_WIN64
/* For fastcall/thiscall this is first register-passed /* For fastcall/thiscall/register this is first register-passed
argument. */ argument. */
if (cabi == FFI_THISCALL || cabi == FFI_FASTCALL) if (cabi == FFI_THISCALL || cabi == FFI_FASTCALL || cabi == FFI_REGISTER)
{ {
p_stack_args[stack_args_count] = sizeof (void*);
p_stack_data[stack_args_count] = argp; p_stack_data[stack_args_count] = argp;
++stack_args_count; ++stack_args_count;
} }
@@ -82,23 +82,29 @@ void ffi_prep_args(char *stack, extended_cif *ecif)
argp += sizeof(void*); argp += sizeof(void*);
} }
p_arg = ecif->cif->arg_types;
p_argv = ecif->avalue; p_argv = ecif->avalue;
if (dir < 0)
for (i = ecif->cif->nargs, p_arg = ecif->cif->arg_types;
i != 0;
i--, p_arg++)
{ {
size_t z; const unsigned int nargs = ecif->cif->nargs - 1;
if (nargs > 0)
{
p_arg += nargs;
p_argv += nargs;
}
}
for (i = ecif->cif->nargs; i != 0; i--)
{
/* Align if necessary */ /* Align if necessary */
if ((sizeof(void*) - 1) & (size_t) argp) if ((sizeof(void*) - 1) & (size_t) argp)
argp = (char *) ALIGN(argp, sizeof(void*)); argp = (char *) ALIGN(argp, sizeof(void*));
z = (*p_arg)->size; size_t z = (*p_arg)->size;
#ifdef X86_WIN64 #ifdef X86_WIN64
if (z > sizeof(ffi_arg) if (z > sizeof(ffi_arg)
|| ((*p_arg)->type == FFI_TYPE_STRUCT || ((*p_arg)->type == FFI_TYPE_STRUCT
&& (z != 1 && z != 2 && z != 4 && z != 8)) && (z & (1 | 2 | 4 | 8)) == 0)
#if FFI_TYPE_DOUBLE != FFI_TYPE_LONGDOUBLE #if FFI_TYPE_DOUBLE != FFI_TYPE_LONGDOUBLE
|| ((*p_arg)->type == FFI_TYPE_LONGDOUBLE) || ((*p_arg)->type == FFI_TYPE_LONGDOUBLE)
#endif #endif
@@ -156,23 +162,33 @@ void ffi_prep_args(char *stack, extended_cif *ecif)
} }
#ifndef X86_WIN64 #ifndef X86_WIN64
/* For thiscall/fastcall convention register-passed arguments /* For thiscall/fastcall/register convention register-passed arguments
are the first two none-floating-point arguments with a size are the first two none-floating-point arguments with a size
smaller or equal to sizeof (void*). */ smaller or equal to sizeof (void*). */
if ((cabi == FFI_THISCALL && stack_args_count < 1) if ((z == sizeof(ffi_arg))
&& ((cabi == FFI_REGISTER)
|| (cabi == FFI_THISCALL && stack_args_count < 1)
|| (cabi == FFI_FASTCALL && stack_args_count < 2)) || (cabi == FFI_FASTCALL && stack_args_count < 2))
&& ((*p_arg)->type != FFI_TYPE_FLOAT && (*p_arg)->type != FFI_TYPE_STRUCT)
)
{ {
if (z <= 4 if (dir < 0 && stack_args_count > 2)
&& ((*p_arg)->type != FFI_TYPE_FLOAT
&& (*p_arg)->type != FFI_TYPE_STRUCT))
{ {
p_stack_args[stack_args_count] = z; /* Iterating arguments backwards, so first register-passed argument
will be passed last. Shift temporary values to make place. */
p_stack_data[0] = p_stack_data[1];
p_stack_data[1] = p_stack_data[2];
stack_args_count = 2;
}
p_stack_data[stack_args_count] = argp; p_stack_data[stack_args_count] = argp;
++stack_args_count; ++stack_args_count;
} }
}
#endif #endif
p_argv++;
p_arg += dir;
p_argv += dir;
#ifdef X86_WIN64 #ifdef X86_WIN64
argp += (z + sizeof(void*) - 1) & ~(sizeof(void*) - 1); argp += (z + sizeof(void*) - 1) & ~(sizeof(void*) - 1);
#else #else
@@ -181,44 +197,35 @@ void ffi_prep_args(char *stack, extended_cif *ecif)
} }
#ifndef X86_WIN64 #ifndef X86_WIN64
/* We need to move the register-passed arguments for thiscall/fastcall /* We need to move the register-passed arguments for thiscall/fastcall/register
on top of stack, so that those can be moved to registers ecx/edx by on top of stack, so that those can be moved to registers by call-handler. */
call-handler. */
if (stack_args_count > 0) if (stack_args_count > 0)
{ {
size_t zz = (p_stack_args[0] + 3) & ~3; int i;
char *h; if (dir < 0 && stack_args_count > 1)
/* Move first argument to top-stack position. */
if (p_stack_data[0] != argp2)
{ {
h = alloca (zz + 1); /* Reverse order if iterating arguments backwards */
memcpy (h, p_stack_data[0], zz); ffi_arg tmp = *(ffi_arg*) p_stack_data[0];
memmove (argp2 + zz, argp2, *(ffi_arg*) p_stack_data[0] = *(ffi_arg*) p_stack_data[stack_args_count - 1];
(size_t) ((char *) p_stack_data[0] - (char*)argp2)); *(ffi_arg*) p_stack_data[stack_args_count - 1] = tmp;
memcpy (argp2, h, zz);
} }
argp2 += zz; for (i = 0; i < stack_args_count; i++)
--stack_args_count;
if (zz > 4)
stack_args_count = 0;
/* If we have a second argument, then move it on top
after the first one. */
if (stack_args_count > 0 && p_stack_data[1] != argp2)
{ {
zz = p_stack_args[1]; if (p_stack_data[i] != argp2)
zz = (zz + 3) & ~3; {
h = alloca (zz + 1); ffi_arg tmp = *(ffi_arg*) p_stack_data[i];
h = alloca (zz + 1); memmove (argp2 + sizeof(ffi_arg), argp2, (size_t) ((char*) p_stack_data[i] - (char*)argp2));
memcpy (h, p_stack_data[1], zz); *(ffi_arg *) argp2 = tmp;
memmove (argp2 + zz, argp2, (size_t) ((char*) p_stack_data[1] - (char*)argp2)); }
memcpy (argp2, h, zz);
argp2 += sizeof(ffi_arg);
} }
} }
return stack_args_count;
#endif #endif
return; return 0;
} }
/* Perform machine dependent cif processing */ /* Perform machine dependent cif processing */
@@ -387,37 +394,12 @@ void ffi_call(ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue)
case FFI_MS_CDECL: case FFI_MS_CDECL:
#endif #endif
case FFI_STDCALL: case FFI_STDCALL:
ffi_call_win32(ffi_prep_args, &ecif, cif->abi, cif->bytes, cif->flags,
ecif.rvalue, fn);
break;
case FFI_THISCALL: case FFI_THISCALL:
case FFI_FASTCALL: case FFI_FASTCALL:
{ case FFI_PASCAL:
unsigned int abi = cif->abi; case FFI_REGISTER:
unsigned int i, passed_regs = 0; ffi_call_win32(ffi_prep_args, &ecif, cif->abi, cif->bytes, cif->flags,
if (cif->flags == FFI_TYPE_STRUCT)
++passed_regs;
for (i=0; i < cif->nargs && passed_regs < 2;i++)
{
size_t sz;
if (cif->arg_types[i]->type == FFI_TYPE_FLOAT
|| cif->arg_types[i]->type == FFI_TYPE_STRUCT)
continue;
sz = (cif->arg_types[i]->size + 3) & ~3;
if (sz == 0 || sz > 4)
continue;
++passed_regs;
}
if (passed_regs < 2 && abi == FFI_FASTCALL)
abi = FFI_THISCALL;
if (passed_regs < 1 && abi == FFI_THISCALL)
abi = FFI_STDCALL;
ffi_call_win32(ffi_prep_args, &ecif, abi, cif->bytes, cif->flags,
ecif.rvalue, fn); ecif.rvalue, fn);
}
break; break;
#endif #endif
default: default:
@@ -764,10 +746,36 @@ ffi_prep_raw_closure_loc (ffi_raw_closure* closure,
return FFI_OK; return FFI_OK;
} }
static void static unsigned int
ffi_prep_args_raw(char *stack, extended_cif *ecif) ffi_prep_args_raw(char *stack, extended_cif *ecif)
{ {
memcpy (stack, ecif->avalue, ecif->cif->bytes); const ffi_cif *cif = ecif->cif;
const unsigned int abi = cif->abi;
const unsigned int max = (abi == FFI_THISCALL) ? 1
: (abi == FFI_FASTCALL) ? 2
: (abi == FFI_REGISTER) ? 3
: 0;
unsigned int i, passed_regs = 0;
if (cif->flags == FFI_TYPE_STRUCT)
++passed_regs;
for (i = 0; i < cif->nargs && passed_regs <= max; i++)
{
if (cif->arg_types[i]->type == FFI_TYPE_FLOAT
|| cif->arg_types[i]->type == FFI_TYPE_STRUCT)
continue;
size_t sz = (cif->arg_types[i]->size + 3) & ~3;
if (sz == 0 || sz > 4)
continue;
++passed_regs;
}
memcpy (stack, ecif->avalue, cif->bytes);
return passed_regs;
} }
/* we borrow this routine from libffi (it must be changed, though, to /* we borrow this routine from libffi (it must be changed, though, to
@@ -810,37 +818,12 @@ ffi_raw_call(ffi_cif *cif, void (*fn)(void), void *rvalue, ffi_raw *fake_avalue)
#endif #endif
#ifndef X86_WIN64 #ifndef X86_WIN64
case FFI_STDCALL: case FFI_STDCALL:
ffi_call_win32(ffi_prep_args_raw, &ecif, cif->abi, cif->bytes, cif->flags,
ecif.rvalue, fn);
break;
case FFI_THISCALL: case FFI_THISCALL:
case FFI_FASTCALL: case FFI_FASTCALL:
{ case FFI_PASCAL:
unsigned int abi = cif->abi; case FFI_REGISTER:
unsigned int i, passed_regs = 0; ffi_call_win32(ffi_prep_args_raw, &ecif, cif->abi, cif->bytes, cif->flags,
if (cif->flags == FFI_TYPE_STRUCT)
++passed_regs;
for (i=0; i < cif->nargs && passed_regs < 2;i++)
{
size_t sz;
if (cif->arg_types[i]->type == FFI_TYPE_FLOAT
|| cif->arg_types[i]->type == FFI_TYPE_STRUCT)
continue;
sz = (cif->arg_types[i]->size + 3) & ~3;
if (sz == 0 || sz > 4)
continue;
++passed_regs;
}
if (passed_regs < 2 && abi == FFI_FASTCALL)
cif->abi = abi = FFI_THISCALL;
if (passed_regs < 1 && abi == FFI_THISCALL)
cif->abi = abi = FFI_STDCALL;
ffi_call_win32(ffi_prep_args_raw, &ecif, abi, cif->bytes, cif->flags,
ecif.rvalue, fn); ecif.rvalue, fn);
}
break; break;
#endif #endif
default: default:

4
src/x86/ffitarget.h
View File

@@ -82,6 +82,8 @@ typedef enum ffi_abi {
FFI_THISCALL, FFI_THISCALL,
FFI_FASTCALL, FFI_FASTCALL,
FFI_MS_CDECL, FFI_MS_CDECL,
FFI_PASCAL,
FFI_REGISTER,
FFI_LAST_ABI, FFI_LAST_ABI,
#ifdef _MSC_VER #ifdef _MSC_VER
FFI_DEFAULT_ABI = FFI_MS_CDECL FFI_DEFAULT_ABI = FFI_MS_CDECL
@@ -101,6 +103,8 @@ typedef enum ffi_abi {
FFI_THISCALL, FFI_THISCALL,
FFI_FASTCALL, FFI_FASTCALL,
FFI_STDCALL, FFI_STDCALL,
FFI_PASCAL,
FFI_REGISTER,
FFI_LAST_ABI, FFI_LAST_ABI,
#if defined(__i386__) || defined(__i386) #if defined(__i386__) || defined(__i386)
FFI_DEFAULT_ABI = FFI_SYSV FFI_DEFAULT_ABI = FFI_SYSV

90
src/x86/win32.S
View File

@@ -63,32 +63,44 @@ ffi_call_win32 PROC NEAR,
mov eax, esp mov eax, esp
;; Place all of the ffi_prep_args in position ;; Call ffi_prep_args
push ecif push ecif
push eax push eax
call ffi_prep_args call ffi_prep_args
;; Return stack to previous state and call the function
add esp, 8 add esp, 8
;; Handle thiscall and fastcall ;; Prepare registers
cmp cif_abi, 3 ;; FFI_THISCALL ;; EAX stores the number of register arguments
jz do_thiscall cmp eax, 0
cmp cif_abi, 4 ;; FFI_FASTCALL je fun
jnz do_stdcall cmp eax, 3
mov ecx, DWORD PTR [esp] jl prepr_two_cmp
mov edx, DWORD PTR [esp+4]
mov ecx, esp
add esp, 12
mov eax, DWORD PTR [ecx+8]
jmp prepr_two
prepr_two_cmp:
cmp eax, 2
jl prepr_one_prep
mov ecx, esp
add esp, 8 add esp, 8
jmp do_stdcall prepr_two:
do_thiscall: mov edx, DWORD PTR [ecx+4]
mov ecx, DWORD PTR [esp] jmp prepr_one
prepr_one_prep:
mov ecx, esp
add esp, 4 add esp, 4
do_stdcall: prepr_one:
call fn mov ecx, DWORD PTR [ecx]
cmp cif_abi, 7 ;; FFI_REGISTER
jne fun
;; cdecl: we restore esp in the epilogue, so there's no need to xchg ecx, eax
;; remove the space we pushed for the args.
;; stdcall: the callee has already cleaned the stack. fun:
;; Call function
call fn
;; Load ecx with the return type code ;; Load ecx with the return type code
mov ecx, cif_flags mov ecx, cif_flags
@@ -531,32 +543,46 @@ USCORE_SYMBOL(ffi_call_win32):
movl %esp,%eax movl %esp,%eax
# Place all of the ffi_prep_args in position # Call ffi_prep_args
pushl 12(%ebp) pushl 12(%ebp)
pushl %eax pushl %eax
call *8(%ebp) call *8(%ebp)
# Return stack to previous state and call the function
addl $8,%esp addl $8,%esp
# Handle fastcall and thiscall # Prepare registers
cmpl $3, 16(%ebp) # FFI_THISCALL # EAX stores the number of register arguments
jz .do_thiscall cmpl $0, %eax
cmpl $4, 16(%ebp) # FFI_FASTCALL je .fun
jnz .do_fncall cmpl $3, %eax
movl (%esp), %ecx jl .prepr_two_cmp
movl 4(%esp), %edx
movl %esp, %ecx
addl $12, %esp
movl 8(%ecx), %eax
jmp .prepr_two
.prepr_two_cmp:
cmpl $2, %eax
jl .prepr_one_prep
movl %esp, %ecx
addl $8, %esp addl $8, %esp
jmp .do_fncall .prepr_two:
.do_thiscall: movl 4(%ecx), %edx
movl (%esp), %ecx jmp .prepr_one
.prepr_one_prep:
movl %esp, %ecx
addl $4, %esp addl $4, %esp
.prepr_one:
movl (%ecx), %ecx
cmpl $7, 16(%ebp) # FFI_REGISTER
jne .fun
.do_fncall: xchgl %eax, %ecx
.fun:
# FIXME: Align the stack to a 128-bit boundary to avoid # FIXME: Align the stack to a 128-bit boundary to avoid
# potential performance hits. # potential performance hits.
# Call function
call *32(%ebp) call *32(%ebp)
# stdcall functions pop arguments off the stack themselves # stdcall functions pop arguments off the stack themselves