#include <ffi.h>
#include <ffi_common.h>
#include <stdlib.h>
#define ROUND_UP(v, a) (((size_t)(v) + (a) - 1) & ~((a) - 1))
#define ROUND_DOWN(v, a) (((size_t)(v) - (a) + 1) & ~((a) - 1))
#define MIN_STACK_SIZE 64
#define FIRST_ARG_SLOT 9
#define DEBUG_LEVEL 0
#define fldw(addr, fpreg) asm volatile ("fldw 0(%0), %%" #fpreg "L" : : "r"(addr) : #fpreg)
#define fstw(fpreg, addr) asm volatile ("fstw %%" #fpreg "L, 0(%0)" : : "r"(addr))
#define fldd(addr, fpreg) asm volatile ("fldd 0(%0), %%" #fpreg : : "r"(addr) : #fpreg)
#define fstd(fpreg, addr) asm volatile ("fstd %%" #fpreg "L, 0(%0)" : : "r"(addr))
#define debug(lvl, x...) do { if (lvl <= DEBUG_LEVEL) { printf(x); } } while (0)
static inline int ffi_struct_type(ffi_type *t)
{
size_t sz = t->size;
if (sz <= 1)
return FFI_TYPE_UINT8;
else if (sz == 2)
return FFI_TYPE_UINT16;
else if (sz == 3)
return FFI_TYPE_SMALL_STRUCT1;
else if (sz == 4)
return FFI_TYPE_UINT32;
else if (sz <= 6)
return FFI_TYPE_SMALL_STRUCT2;
else if (sz <= 8)
return FFI_TYPE_UINT64;
else
return FFI_TYPE_STRUCT;
}
void ffi_prep_args_LINUX(UINT32 *stack, extended_cif *ecif, unsigned bytes)
{
register unsigned int i;
register ffi_type **p_arg;
register void **p_argv;
unsigned int slot = FIRST_ARG_SLOT - 1;
char *dest_cpy;
debug(1, "%s: stack = %p, ecif = %p, bytes = %u\n", __FUNCTION__, stack, ecif, bytes);
p_arg = ecif->cif->arg_types;
p_argv = ecif->avalue;
for (i = 0; i < ecif->cif->nargs; i++)
{
int type = (*p_arg)->type;
switch (type)
{
case FFI_TYPE_SINT8:
slot++;
*(SINT32 *)(stack - slot) = *(SINT8 *)(*p_argv);
break;
case FFI_TYPE_UINT8:
slot++;
*(UINT32 *)(stack - slot) = *(UINT8 *)(*p_argv);
break;
case FFI_TYPE_SINT16:
slot++;
*(SINT32 *)(stack - slot) = *(SINT16 *)(*p_argv);
break;
case FFI_TYPE_UINT16:
slot++;
*(UINT32 *)(stack - slot) = *(UINT16 *)(*p_argv);
break;
case FFI_TYPE_UINT32:
case FFI_TYPE_SINT32:
case FFI_TYPE_POINTER:
slot++;
debug(3, "Storing UINT32 %u in slot %u\n", *(UINT32 *)(*p_argv), slot);
*(UINT32 *)(stack - slot) = *(UINT32 *)(*p_argv);
break;
case FFI_TYPE_UINT64:
case FFI_TYPE_SINT64:
slot += 2;
if (slot & 1)
slot++;
*(UINT32 *)(stack - slot) = (*(UINT64 *)(*p_argv)) >> 32;
*(UINT32 *)(stack - slot + 1) = (*(UINT64 *)(*p_argv)) & 0xffffffffUL;
break;
case FFI_TYPE_FLOAT:
slot++;
switch (slot - FIRST_ARG_SLOT)
{
case 0: fldw(*p_argv, fr4); break;
case 1: fldw(*p_argv, fr5); break;
case 2: fldw(*p_argv, fr6); break;
case 3: fldw(*p_argv, fr7); break;
default:
debug(3, "Storing UINT32(float) in slot %u\n", slot);
*(UINT32 *)(stack - slot) = *(UINT32 *)(*p_argv);
break;
}
break;
case FFI_TYPE_DOUBLE:
slot += 2;
if (slot & 1)
slot++;
switch (slot - FIRST_ARG_SLOT + 1)
{
case 2: fldd(*p_argv, fr5); break;
case 4: fldd(*p_argv, fr7); break;
default:
debug(3, "Storing UINT64(double) at slot %u\n", slot);
*(UINT64 *)(stack - slot) = *(UINT64 *)(*p_argv);
break;
}
break;
case FFI_TYPE_STRUCT:
if((*p_arg)->size <= 4)
{
slot++;
dest_cpy = (char *)(stack - slot);
dest_cpy += 4 - (*p_arg)->size;
memcpy((char *)dest_cpy, (char *)*p_argv, (*p_arg)->size);
}
else if ((*p_arg)->size <= 8)
{
slot += 2;
if (slot & 1)
slot++;
dest_cpy = (char *)(stack - slot);
dest_cpy += 8 - (*p_arg)->size;
memcpy((char *)dest_cpy, (char *)*p_argv, (*p_arg)->size);
}
else
{
slot++;
*(UINT32 *)(stack - slot) = (UINT32)(*p_argv);
}
break;
default:
FFI_ASSERT(0);
}
p_arg++;
p_argv++;
}
{
int n;
debug(5, "Stack setup:\n");
for (n = 0; n < (bytes + 3) / 4; n++)
{
if ((n%4) == 0) { debug(5, "\n%08x: ", (unsigned int)(stack - n)); }
debug(5, "%08x ", *(stack - n));
}
debug(5, "\n");
}
FFI_ASSERT(slot * 4 <= bytes);
return;
}
static void ffi_size_stack_LINUX(ffi_cif *cif)
{
ffi_type **ptr;
int i;
int z = 0;
for (ptr = cif->arg_types, i = 0; i < cif->nargs; ptr++, i++)
{
int type = (*ptr)->type;
switch (type)
{
case FFI_TYPE_DOUBLE:
case FFI_TYPE_UINT64:
case FFI_TYPE_SINT64:
z += 2 + (z & 1);
break;
case FFI_TYPE_STRUCT:
z += 1;
break;
default:
z++;
}
}
if (z <= 6)
cif->bytes = MIN_STACK_SIZE;
else
cif->bytes = 64 + ROUND_UP((z - 6) * sizeof(UINT32), MIN_STACK_SIZE);
debug(3, "Calculated stack size is %u bytes\n", cif->bytes);
}
ffi_status ffi_prep_cif_machdep(ffi_cif *cif)
{
switch (cif->rtype->type)
{
case FFI_TYPE_VOID:
case FFI_TYPE_FLOAT:
case FFI_TYPE_DOUBLE:
cif->flags = (unsigned) cif->rtype->type;
break;
case FFI_TYPE_STRUCT:
cif->flags = ffi_struct_type(cif->rtype);
break;
case FFI_TYPE_UINT64:
case FFI_TYPE_SINT64:
cif->flags = FFI_TYPE_UINT64;
break;
default:
cif->flags = FFI_TYPE_INT;
break;
}
switch (cif->abi)
{
case FFI_LINUX:
ffi_size_stack_LINUX(cif);
break;
default:
FFI_ASSERT(0);
break;
}
return FFI_OK;
}
extern void ffi_call_LINUX(void (*)(UINT32 *, extended_cif *, unsigned),
extended_cif *,
unsigned, unsigned,
unsigned *,
void (*fn)());
void ffi_call( ffi_cif *cif,
void (*fn)(),
void *rvalue,
void **avalue)
{
extended_cif ecif;
ecif.cif = cif;
ecif.avalue = avalue;
if ((rvalue == NULL) &&
(cif->rtype->type == FFI_TYPE_STRUCT))
{
ecif.rvalue = alloca(cif->rtype->size);
}
else
ecif.rvalue = rvalue;
switch (cif->abi)
{
case FFI_LINUX:
debug(2, "Calling ffi_call_LINUX: ecif=%p, bytes=%u, flags=%u, rvalue=%p, fn=%p\n", &ecif, cif->bytes, cif->flags, ecif.rvalue, (void *)fn);
ffi_call_LINUX(ffi_prep_args_LINUX, &ecif, cif->bytes,
cif->flags, ecif.rvalue, fn);
break;
default:
FFI_ASSERT(0);
break;
}
}
#if FFI_CLOSURES
UINT32 ffi_closure_inner_LINUX(ffi_closure *closure, UINT32 *stack)
{
ffi_cif *cif;
void **avalue;
void *rvalue;
UINT32 ret[2];
ffi_type **p_arg;
char *tmp;
int i, avn, slot = FIRST_ARG_SLOT - 1;
register UINT32 r28 asm("r28");
cif = closure->cif;
if (cif->flags == FFI_TYPE_STRUCT)
rvalue = (void *)r28;
else
rvalue = &ret[0];
avalue = (void **)alloca(cif->nargs * FFI_SIZEOF_ARG);
avn = cif->nargs;
p_arg = cif->arg_types;
for (i = 0; i < avn; i++)
{
int type = (*p_arg)->type;
switch (type)
{
case FFI_TYPE_SINT8:
case FFI_TYPE_UINT8:
case FFI_TYPE_SINT16:
case FFI_TYPE_UINT16:
case FFI_TYPE_SINT32:
case FFI_TYPE_UINT32:
case FFI_TYPE_POINTER:
slot++;
avalue[i] = (char *)(stack - slot) + sizeof(UINT32) - (*p_arg)->size;
break;
case FFI_TYPE_SINT64:
case FFI_TYPE_UINT64:
slot += 2;
if (slot & 1)
slot++;
avalue[i] = (void *)(stack - slot);
break;
case FFI_TYPE_FLOAT:
slot++;
switch (slot - FIRST_ARG_SLOT)
{
case 0: fstw(fr4, (void *)(stack - slot)); break;
case 1: fstw(fr5, (void *)(stack - slot)); break;
case 2: fstw(fr6, (void *)(stack - slot)); break;
case 3: fstw(fr7, (void *)(stack - slot)); break;
}
avalue[i] = (void *)(stack - slot);
break;
case FFI_TYPE_DOUBLE:
slot += 2;
if (slot & 1)
slot++;
switch (slot - FIRST_ARG_SLOT + 1)
{
case 2: fstd(fr5, (void *)(stack - slot)); break;
case 4: fstd(fr7, (void *)(stack - slot)); break;
}
avalue[i] = (void *)(stack - slot);
break;
case FFI_TYPE_STRUCT:
if((*p_arg)->size <= 4) {
slot++;
avalue[i] = (void *)(stack - slot) + sizeof(UINT32) -
(*p_arg)->size;
} else if ((*p_arg)->size <= 8) {
slot += 2;
if (slot & 1)
slot++;
avalue[i] = (void *)(stack - slot) + sizeof(UINT64) -
(*p_arg)->size;
} else {
slot++;
avalue[i] = (void *) *(stack - slot);
}
break;
default:
FFI_ASSERT(0);
}
p_arg++;
}
(closure->fun) (cif, rvalue, avalue, closure->user_data);
debug(3, "after calling function, ret[0] = %d, ret[1] = %d\n", ret[0], ret[1]);
switch (cif->flags)
{
case FFI_TYPE_UINT8:
*(stack - FIRST_ARG_SLOT) = *(UINT8 *)&ret[0];
break;
case FFI_TYPE_SINT8:
*(stack - FIRST_ARG_SLOT) = *(SINT8 *)&ret[0];
break;
case FFI_TYPE_UINT16:
*(stack - FIRST_ARG_SLOT) = *(UINT16 *)&ret[0];
break;
case FFI_TYPE_SINT16:
*(stack - FIRST_ARG_SLOT) = *(SINT16 *)&ret[0];
break;
case FFI_TYPE_INT:
case FFI_TYPE_UINT32:
*(stack - FIRST_ARG_SLOT) = *(UINT32 *)&ret[0];
break;
case FFI_TYPE_SINT32:
*(stack - FIRST_ARG_SLOT) = *(SINT32 *)&ret[0];
break;
case FFI_TYPE_SINT64:
case FFI_TYPE_UINT64:
*(stack - FIRST_ARG_SLOT) = *(UINT32 *)&ret[0];
*(stack - FIRST_ARG_SLOT - 1) = *(UINT32 *)&ret[1];
break;
case FFI_TYPE_DOUBLE:
fldd(rvalue, fr4);
break;
case FFI_TYPE_FLOAT:
fldw(rvalue, fr4);
break;
case FFI_TYPE_STRUCT:
break;
case FFI_TYPE_SMALL_STRUCT1:
tmp = (void*)(stack - FIRST_ARG_SLOT);
tmp += 4 - cif->rtype->size;
memcpy((void*)tmp, &ret[0], cif->rtype->size);
break;
case FFI_TYPE_SMALL_STRUCT2:
*(stack - FIRST_ARG_SLOT) = ret[0];
*(stack - FIRST_ARG_SLOT - 1) = ret[1];
break;
case FFI_TYPE_POINTER:
case FFI_TYPE_VOID:
break;
default:
debug(0, "assert with cif->flags: %d\n",cif->flags);
FFI_ASSERT(0);
break;
}
return FFI_OK;
}
void ffi_closure_LINUX(void);
ffi_status
ffi_prep_closure (ffi_closure* closure,
ffi_cif* cif,
void (*fun)(ffi_cif*,void*,void**,void*),
void *user_data)
{
UINT32 *tramp = (UINT32 *)(closure->tramp);
FFI_ASSERT (cif->abi == FFI_LINUX);
tramp[0] = 0xeaa00000;
tramp[1] = 0xd6a01c1e;
tramp[2] = 0x4aa10028;
tramp[3] = 0x36b53ff1;
tramp[4] = 0x0c201096;
tramp[5] = 0xeac0c000;
tramp[6] = 0x0c281093;
tramp[7] = ((UINT32)(ffi_closure_LINUX) & ~2);
asm volatile (
"fdc 0(%0)\n"
"fdc %1(%0)\n"
"fic 0(%%sr4, %0)\n"
"fic %1(%%sr4, %0)\n"
"sync\n"
: : "r"((unsigned long)tramp & ~31), "r"(32 ));
closure->cif = cif;
closure->user_data = user_data;
closure->fun = fun;
return FFI_OK;
}
#endif