626 lines
15 KiB
C
626 lines
15 KiB
C
/* -----------------------------------------------------------------------
|
|
ffi.c - Copyright (c) 1996, 2003, 2004, 2007, 2008 Red Hat, Inc.
|
|
|
|
SPARC 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 THE AUTHORS OR COPYRIGHT
|
|
HOLDERS 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 */
|
|
|
|
void ffi_prep_args_v8(char *stack, extended_cif *ecif)
|
|
{
|
|
int i;
|
|
void **p_argv;
|
|
char *argp;
|
|
ffi_type **p_arg;
|
|
|
|
/* Skip 16 words for the window save area */
|
|
argp = stack + 16*sizeof(int);
|
|
|
|
/* This should only really be done when we are returning a structure,
|
|
however, it's faster just to do it all the time...
|
|
|
|
if ( ecif->cif->rtype->type == FFI_TYPE_STRUCT ) */
|
|
*(int *) argp = (long)ecif->rvalue;
|
|
|
|
/* And 1 word for the structure return value. */
|
|
argp += sizeof(int);
|
|
|
|
#ifdef USING_PURIFY
|
|
/* Purify will probably complain in our assembly routine, unless we
|
|
zero out this memory. */
|
|
|
|
((int*)argp)[0] = 0;
|
|
((int*)argp)[1] = 0;
|
|
((int*)argp)[2] = 0;
|
|
((int*)argp)[3] = 0;
|
|
((int*)argp)[4] = 0;
|
|
((int*)argp)[5] = 0;
|
|
#endif
|
|
|
|
p_argv = ecif->avalue;
|
|
|
|
for (i = ecif->cif->nargs, p_arg = ecif->cif->arg_types; i; i--, p_arg++)
|
|
{
|
|
size_t z;
|
|
|
|
if ((*p_arg)->type == FFI_TYPE_STRUCT
|
|
#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
|
|
|| (*p_arg)->type == FFI_TYPE_LONGDOUBLE
|
|
#endif
|
|
)
|
|
{
|
|
*(unsigned int *) argp = (unsigned long)(* p_argv);
|
|
z = sizeof(int);
|
|
}
|
|
else
|
|
{
|
|
z = (*p_arg)->size;
|
|
if (z < sizeof(int))
|
|
{
|
|
z = sizeof(int);
|
|
switch ((*p_arg)->type)
|
|
{
|
|
case FFI_TYPE_SINT8:
|
|
*(signed int *) argp = *(SINT8 *)(* p_argv);
|
|
break;
|
|
|
|
case FFI_TYPE_UINT8:
|
|
*(unsigned int *) argp = *(UINT8 *)(* p_argv);
|
|
break;
|
|
|
|
case FFI_TYPE_SINT16:
|
|
*(signed int *) argp = *(SINT16 *)(* p_argv);
|
|
break;
|
|
|
|
case FFI_TYPE_UINT16:
|
|
*(unsigned int *) argp = *(UINT16 *)(* p_argv);
|
|
break;
|
|
|
|
default:
|
|
FFI_ASSERT(0);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
memcpy(argp, *p_argv, z);
|
|
}
|
|
}
|
|
p_argv++;
|
|
argp += z;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
int ffi_prep_args_v9(char *stack, extended_cif *ecif)
|
|
{
|
|
int i, ret = 0;
|
|
int tmp;
|
|
void **p_argv;
|
|
char *argp;
|
|
ffi_type **p_arg;
|
|
|
|
tmp = 0;
|
|
|
|
/* Skip 16 words for the window save area */
|
|
argp = stack + 16*sizeof(long long);
|
|
|
|
#ifdef USING_PURIFY
|
|
/* Purify will probably complain in our assembly routine, unless we
|
|
zero out this memory. */
|
|
|
|
((long long*)argp)[0] = 0;
|
|
((long long*)argp)[1] = 0;
|
|
((long long*)argp)[2] = 0;
|
|
((long long*)argp)[3] = 0;
|
|
((long long*)argp)[4] = 0;
|
|
((long long*)argp)[5] = 0;
|
|
#endif
|
|
|
|
p_argv = ecif->avalue;
|
|
|
|
if (ecif->cif->rtype->type == FFI_TYPE_STRUCT &&
|
|
ecif->cif->rtype->size > 32)
|
|
{
|
|
*(unsigned long long *) argp = (unsigned long)ecif->rvalue;
|
|
argp += sizeof(long long);
|
|
tmp = 1;
|
|
}
|
|
|
|
for (i = 0, p_arg = ecif->cif->arg_types; i < ecif->cif->nargs;
|
|
i++, p_arg++)
|
|
{
|
|
size_t z;
|
|
|
|
z = (*p_arg)->size;
|
|
switch ((*p_arg)->type)
|
|
{
|
|
case FFI_TYPE_STRUCT:
|
|
if (z > 16)
|
|
{
|
|
/* For structures larger than 16 bytes we pass reference. */
|
|
*(unsigned long long *) argp = (unsigned long)* p_argv;
|
|
argp += sizeof(long long);
|
|
tmp++;
|
|
p_argv++;
|
|
continue;
|
|
}
|
|
/* FALLTHROUGH */
|
|
case FFI_TYPE_FLOAT:
|
|
case FFI_TYPE_DOUBLE:
|
|
#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
|
|
case FFI_TYPE_LONGDOUBLE:
|
|
#endif
|
|
ret = 1; /* We should promote into FP regs as well as integer. */
|
|
break;
|
|
}
|
|
if (z < sizeof(long long))
|
|
{
|
|
switch ((*p_arg)->type)
|
|
{
|
|
case FFI_TYPE_SINT8:
|
|
*(signed long long *) argp = *(SINT8 *)(* p_argv);
|
|
break;
|
|
|
|
case FFI_TYPE_UINT8:
|
|
*(unsigned long long *) argp = *(UINT8 *)(* p_argv);
|
|
break;
|
|
|
|
case FFI_TYPE_SINT16:
|
|
*(signed long long *) argp = *(SINT16 *)(* p_argv);
|
|
break;
|
|
|
|
case FFI_TYPE_UINT16:
|
|
*(unsigned long long *) argp = *(UINT16 *)(* p_argv);
|
|
break;
|
|
|
|
case FFI_TYPE_SINT32:
|
|
*(signed long long *) argp = *(SINT32 *)(* p_argv);
|
|
break;
|
|
|
|
case FFI_TYPE_UINT32:
|
|
*(unsigned long long *) argp = *(UINT32 *)(* p_argv);
|
|
break;
|
|
|
|
case FFI_TYPE_FLOAT:
|
|
*(float *) (argp + 4) = *(FLOAT32 *)(* p_argv); /* Right justify */
|
|
break;
|
|
|
|
case FFI_TYPE_STRUCT:
|
|
memcpy(argp, *p_argv, z);
|
|
break;
|
|
|
|
default:
|
|
FFI_ASSERT(0);
|
|
}
|
|
z = sizeof(long long);
|
|
tmp++;
|
|
}
|
|
else if (z == sizeof(long long))
|
|
{
|
|
memcpy(argp, *p_argv, z);
|
|
z = sizeof(long long);
|
|
tmp++;
|
|
}
|
|
else
|
|
{
|
|
if ((tmp & 1) && (*p_arg)->alignment > 8)
|
|
{
|
|
tmp++;
|
|
argp += sizeof(long long);
|
|
}
|
|
memcpy(argp, *p_argv, z);
|
|
z = 2 * sizeof(long long);
|
|
tmp += 2;
|
|
}
|
|
p_argv++;
|
|
argp += z;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* Perform machine dependent cif processing */
|
|
ffi_status ffi_prep_cif_machdep(ffi_cif *cif)
|
|
{
|
|
int wordsize;
|
|
|
|
if (cif->abi != FFI_V9)
|
|
{
|
|
wordsize = 4;
|
|
|
|
/* If we are returning a struct, this will already have been added.
|
|
Otherwise we need to add it because it's always got to be there! */
|
|
|
|
if (cif->rtype->type != FFI_TYPE_STRUCT)
|
|
cif->bytes += wordsize;
|
|
|
|
/* sparc call frames require that space is allocated for 6 args,
|
|
even if they aren't used. Make that space if necessary. */
|
|
|
|
if (cif->bytes < 4*6+4)
|
|
cif->bytes = 4*6+4;
|
|
}
|
|
else
|
|
{
|
|
wordsize = 8;
|
|
|
|
/* sparc call frames require that space is allocated for 6 args,
|
|
even if they aren't used. Make that space if necessary. */
|
|
|
|
if (cif->bytes < 8*6)
|
|
cif->bytes = 8*6;
|
|
}
|
|
|
|
/* Adjust cif->bytes. to include 16 words for the window save area,
|
|
and maybe the struct/union return pointer area, */
|
|
|
|
cif->bytes += 16 * wordsize;
|
|
|
|
/* The stack must be 2 word aligned, so round bytes up
|
|
appropriately. */
|
|
|
|
cif->bytes = ALIGN(cif->bytes, 2 * wordsize);
|
|
|
|
/* Set the return type flag */
|
|
switch (cif->rtype->type)
|
|
{
|
|
case FFI_TYPE_VOID:
|
|
case FFI_TYPE_FLOAT:
|
|
case FFI_TYPE_DOUBLE:
|
|
#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
|
|
case FFI_TYPE_LONGDOUBLE:
|
|
#endif
|
|
cif->flags = cif->rtype->type;
|
|
break;
|
|
|
|
case FFI_TYPE_STRUCT:
|
|
if (cif->abi == FFI_V9 && cif->rtype->size > 32)
|
|
cif->flags = FFI_TYPE_VOID;
|
|
else
|
|
cif->flags = FFI_TYPE_STRUCT;
|
|
break;
|
|
|
|
case FFI_TYPE_SINT8:
|
|
case FFI_TYPE_UINT8:
|
|
case FFI_TYPE_SINT16:
|
|
case FFI_TYPE_UINT16:
|
|
if (cif->abi == FFI_V9)
|
|
cif->flags = FFI_TYPE_INT;
|
|
else
|
|
cif->flags = cif->rtype->type;
|
|
break;
|
|
|
|
case FFI_TYPE_SINT64:
|
|
case FFI_TYPE_UINT64:
|
|
if (cif->abi == FFI_V9)
|
|
cif->flags = FFI_TYPE_INT;
|
|
else
|
|
cif->flags = FFI_TYPE_SINT64;
|
|
break;
|
|
|
|
default:
|
|
cif->flags = FFI_TYPE_INT;
|
|
break;
|
|
}
|
|
return FFI_OK;
|
|
}
|
|
|
|
int ffi_v9_layout_struct(ffi_type *arg, int off, char *ret, char *intg, char *flt)
|
|
{
|
|
ffi_type **ptr = &arg->elements[0];
|
|
|
|
while (*ptr != NULL)
|
|
{
|
|
if (off & ((*ptr)->alignment - 1))
|
|
off = ALIGN(off, (*ptr)->alignment);
|
|
|
|
switch ((*ptr)->type)
|
|
{
|
|
case FFI_TYPE_STRUCT:
|
|
off = ffi_v9_layout_struct(*ptr, off, ret, intg, flt);
|
|
off = ALIGN(off, FFI_SIZEOF_ARG);
|
|
break;
|
|
case FFI_TYPE_FLOAT:
|
|
case FFI_TYPE_DOUBLE:
|
|
#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
|
|
case FFI_TYPE_LONGDOUBLE:
|
|
#endif
|
|
memmove(ret + off, flt + off, (*ptr)->size);
|
|
off += (*ptr)->size;
|
|
break;
|
|
default:
|
|
memmove(ret + off, intg + off, (*ptr)->size);
|
|
off += (*ptr)->size;
|
|
break;
|
|
}
|
|
ptr++;
|
|
}
|
|
return off;
|
|
}
|
|
|
|
|
|
#ifdef SPARC64
|
|
extern int ffi_call_v9(void *, extended_cif *, unsigned,
|
|
unsigned, unsigned *, void (*fn)(void));
|
|
#else
|
|
extern int ffi_call_v8(void *, extended_cif *, unsigned,
|
|
unsigned, unsigned *, void (*fn)(void));
|
|
#endif
|
|
|
|
void ffi_call(ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue)
|
|
{
|
|
extended_cif ecif;
|
|
void *rval = rvalue;
|
|
|
|
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 */
|
|
|
|
ecif.rvalue = rvalue;
|
|
if (cif->rtype->type == FFI_TYPE_STRUCT)
|
|
{
|
|
if (cif->rtype->size <= 32)
|
|
rval = alloca(64);
|
|
else
|
|
{
|
|
rval = NULL;
|
|
if (rvalue == NULL)
|
|
ecif.rvalue = alloca(cif->rtype->size);
|
|
}
|
|
}
|
|
|
|
switch (cif->abi)
|
|
{
|
|
case FFI_V8:
|
|
#ifdef SPARC64
|
|
/* We don't yet support calling 32bit code from 64bit */
|
|
FFI_ASSERT(0);
|
|
#else
|
|
ffi_call_v8(ffi_prep_args_v8, &ecif, cif->bytes,
|
|
cif->flags, rvalue, fn);
|
|
#endif
|
|
break;
|
|
case FFI_V9:
|
|
#ifdef SPARC64
|
|
ffi_call_v9(ffi_prep_args_v9, &ecif, cif->bytes,
|
|
cif->flags, rval, fn);
|
|
if (rvalue && rval && cif->rtype->type == FFI_TYPE_STRUCT)
|
|
ffi_v9_layout_struct(cif->rtype, 0, (char *)rvalue, (char *)rval, ((char *)rval)+32);
|
|
#else
|
|
/* And vice versa */
|
|
FFI_ASSERT(0);
|
|
#endif
|
|
break;
|
|
default:
|
|
FFI_ASSERT(0);
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
#ifdef SPARC64
|
|
extern void ffi_closure_v9(void);
|
|
#else
|
|
extern void ffi_closure_v8(void);
|
|
#endif
|
|
|
|
ffi_status
|
|
ffi_prep_closure_loc (ffi_closure* closure,
|
|
ffi_cif* cif,
|
|
void (*fun)(ffi_cif*, void*, void**, void*),
|
|
void *user_data,
|
|
void *codeloc)
|
|
{
|
|
unsigned int *tramp = (unsigned int *) &closure->tramp[0];
|
|
unsigned long fn;
|
|
#ifdef SPARC64
|
|
/* Trampoline address is equal to the closure address. We take advantage
|
|
of that to reduce the trampoline size by 8 bytes. */
|
|
FFI_ASSERT (cif->abi == FFI_V9);
|
|
fn = (unsigned long) ffi_closure_v9;
|
|
tramp[0] = 0x83414000; /* rd %pc, %g1 */
|
|
tramp[1] = 0xca586010; /* ldx [%g1+16], %g5 */
|
|
tramp[2] = 0x81c14000; /* jmp %g5 */
|
|
tramp[3] = 0x01000000; /* nop */
|
|
*((unsigned long *) &tramp[4]) = fn;
|
|
#else
|
|
unsigned long ctx = (unsigned long) codeloc;
|
|
FFI_ASSERT (cif->abi == FFI_V8);
|
|
fn = (unsigned long) ffi_closure_v8;
|
|
tramp[0] = 0x03000000 | fn >> 10; /* sethi %hi(fn), %g1 */
|
|
tramp[1] = 0x05000000 | ctx >> 10; /* sethi %hi(ctx), %g2 */
|
|
tramp[2] = 0x81c06000 | (fn & 0x3ff); /* jmp %g1+%lo(fn) */
|
|
tramp[3] = 0x8410a000 | (ctx & 0x3ff);/* or %g2, %lo(ctx) */
|
|
#endif
|
|
|
|
closure->cif = cif;
|
|
closure->fun = fun;
|
|
closure->user_data = user_data;
|
|
|
|
/* Flush the Icache. FIXME: alignment isn't certain, assume 8 bytes */
|
|
#ifdef SPARC64
|
|
asm volatile ("flush %0" : : "r" (closure) : "memory");
|
|
asm volatile ("flush %0" : : "r" (((char *) closure) + 8) : "memory");
|
|
#else
|
|
asm volatile ("iflush %0" : : "r" (closure) : "memory");
|
|
asm volatile ("iflush %0" : : "r" (((char *) closure) + 8) : "memory");
|
|
#endif
|
|
|
|
return FFI_OK;
|
|
}
|
|
|
|
int
|
|
ffi_closure_sparc_inner_v8(ffi_closure *closure,
|
|
void *rvalue, unsigned long *gpr, unsigned long *scratch)
|
|
{
|
|
ffi_cif *cif;
|
|
ffi_type **arg_types;
|
|
void **avalue;
|
|
int i, argn;
|
|
|
|
cif = closure->cif;
|
|
arg_types = cif->arg_types;
|
|
avalue = alloca(cif->nargs * sizeof(void *));
|
|
|
|
/* Copy the caller's structure return address so that the closure
|
|
returns the data directly to the caller. */
|
|
if (cif->flags == FFI_TYPE_STRUCT
|
|
#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
|
|
|| cif->flags == FFI_TYPE_LONGDOUBLE
|
|
#endif
|
|
)
|
|
rvalue = (void *) gpr[0];
|
|
|
|
/* Always skip the structure return address. */
|
|
argn = 1;
|
|
|
|
/* Grab the addresses of the arguments from the stack frame. */
|
|
for (i = 0; i < cif->nargs; i++)
|
|
{
|
|
if (arg_types[i]->type == FFI_TYPE_STRUCT
|
|
#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
|
|
|| arg_types[i]->type == FFI_TYPE_LONGDOUBLE
|
|
#endif
|
|
)
|
|
{
|
|
/* Straight copy of invisible reference. */
|
|
avalue[i] = (void *)gpr[argn++];
|
|
}
|
|
else if ((arg_types[i]->type == FFI_TYPE_DOUBLE
|
|
|| arg_types[i]->type == FFI_TYPE_SINT64
|
|
|| arg_types[i]->type == FFI_TYPE_UINT64)
|
|
/* gpr is 8-byte aligned. */
|
|
&& (argn % 2) != 0)
|
|
{
|
|
/* Align on a 8-byte boundary. */
|
|
scratch[0] = gpr[argn];
|
|
scratch[1] = gpr[argn+1];
|
|
avalue[i] = scratch;
|
|
scratch -= 2;
|
|
argn += 2;
|
|
}
|
|
else
|
|
{
|
|
/* Always right-justify. */
|
|
argn += ALIGN(arg_types[i]->size, FFI_SIZEOF_ARG) / FFI_SIZEOF_ARG;
|
|
avalue[i] = ((char *) &gpr[argn]) - arg_types[i]->size;
|
|
}
|
|
}
|
|
|
|
/* Invoke the closure. */
|
|
(closure->fun) (cif, rvalue, avalue, closure->user_data);
|
|
|
|
/* Tell ffi_closure_sparc how to perform return type promotions. */
|
|
return cif->rtype->type;
|
|
}
|
|
|
|
int
|
|
ffi_closure_sparc_inner_v9(ffi_closure *closure,
|
|
void *rvalue, unsigned long *gpr, double *fpr)
|
|
{
|
|
ffi_cif *cif;
|
|
ffi_type **arg_types;
|
|
void **avalue;
|
|
int i, argn, fp_slot_max;
|
|
|
|
cif = closure->cif;
|
|
arg_types = cif->arg_types;
|
|
avalue = alloca(cif->nargs * sizeof(void *));
|
|
|
|
/* Copy the caller's structure return address so that the closure
|
|
returns the data directly to the caller. */
|
|
if (cif->flags == FFI_TYPE_VOID
|
|
&& cif->rtype->type == FFI_TYPE_STRUCT)
|
|
{
|
|
rvalue = (void *) gpr[0];
|
|
/* Skip the structure return address. */
|
|
argn = 1;
|
|
}
|
|
else
|
|
argn = 0;
|
|
|
|
fp_slot_max = 16 - argn;
|
|
|
|
/* Grab the addresses of the arguments from the stack frame. */
|
|
for (i = 0; i < cif->nargs; i++)
|
|
{
|
|
if (arg_types[i]->type == FFI_TYPE_STRUCT)
|
|
{
|
|
if (arg_types[i]->size > 16)
|
|
{
|
|
/* Straight copy of invisible reference. */
|
|
avalue[i] = (void *)gpr[argn++];
|
|
}
|
|
else
|
|
{
|
|
/* Left-justify. */
|
|
ffi_v9_layout_struct(arg_types[i],
|
|
0,
|
|
(char *) &gpr[argn],
|
|
(char *) &gpr[argn],
|
|
(char *) &fpr[argn]);
|
|
avalue[i] = &gpr[argn];
|
|
argn += ALIGN(arg_types[i]->size, FFI_SIZEOF_ARG) / FFI_SIZEOF_ARG;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* Right-justify. */
|
|
argn += ALIGN(arg_types[i]->size, FFI_SIZEOF_ARG) / FFI_SIZEOF_ARG;
|
|
|
|
/* Align on a 16-byte boundary. */
|
|
#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
|
|
if (arg_types[i]->type == FFI_TYPE_LONGDOUBLE && (argn % 2) != 0)
|
|
argn++;
|
|
#endif
|
|
if (i < fp_slot_max
|
|
&& (arg_types[i]->type == FFI_TYPE_FLOAT
|
|
|| arg_types[i]->type == FFI_TYPE_DOUBLE
|
|
#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
|
|
|| arg_types[i]->type == FFI_TYPE_LONGDOUBLE
|
|
#endif
|
|
))
|
|
avalue[i] = ((char *) &fpr[argn]) - arg_types[i]->size;
|
|
else
|
|
avalue[i] = ((char *) &gpr[argn]) - arg_types[i]->size;
|
|
}
|
|
}
|
|
|
|
/* Invoke the closure. */
|
|
(closure->fun) (cif, rvalue, avalue, closure->user_data);
|
|
|
|
/* Tell ffi_closure_sparc how to perform return type promotions. */
|
|
return cif->rtype->type;
|
|
}
|