/* -----------------------------------------------------------------------
|
ffi.c - Copyright (c) 2013 Tensilica, Inc.
|
|
XTENSA 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>
|
|
/*
|
|----------------------------------------|
|
| |
|
on entry to ffi_call ----> |----------------------------------------|
|
| caller stack frame for registers a0-a3 |
|
|----------------------------------------|
|
| |
|
| additional arguments |
|
entry of the function ---> |----------------------------------------|
|
| copy of function arguments a2-a7 |
|
| - - - - - - - - - - - - - |
|
| |
|
|
The area below the entry line becomes the new stack frame for the function.
|
|
*/
|
|
|
#define FFI_TYPE_STRUCT_REGS FFI_TYPE_LAST
|
|
|
extern void ffi_call_SYSV(void *rvalue, unsigned rsize, unsigned flags,
|
void(*fn)(void), unsigned nbytes, extended_cif*);
|
extern void ffi_closure_SYSV(void) FFI_HIDDEN;
|
|
ffi_status ffi_prep_cif_machdep(ffi_cif *cif)
|
{
|
switch(cif->rtype->type) {
|
case FFI_TYPE_SINT8:
|
case FFI_TYPE_UINT8:
|
case FFI_TYPE_SINT16:
|
case FFI_TYPE_UINT16:
|
cif->flags = cif->rtype->type;
|
break;
|
case FFI_TYPE_VOID:
|
case FFI_TYPE_FLOAT:
|
cif->flags = FFI_TYPE_UINT32;
|
break;
|
case FFI_TYPE_DOUBLE:
|
case FFI_TYPE_UINT64:
|
case FFI_TYPE_SINT64:
|
cif->flags = FFI_TYPE_UINT64; // cif->rtype->type;
|
break;
|
case FFI_TYPE_STRUCT:
|
cif->flags = FFI_TYPE_STRUCT; //_REGS;
|
/* Up to 16 bytes are returned in registers */
|
if (cif->rtype->size > 4 * 4) {
|
/* returned structure is referenced by a register; use 8 bytes
|
(including 4 bytes for potential additional alignment) */
|
cif->flags = FFI_TYPE_STRUCT;
|
cif->bytes += 8;
|
}
|
break;
|
|
default:
|
cif->flags = FFI_TYPE_UINT32;
|
break;
|
}
|
|
/* Round the stack up to a full 4 register frame, just in case
|
(we use this size in movsp). This way, it's also a multiple of
|
8 bytes for 64-bit arguments. */
|
cif->bytes = ALIGN(cif->bytes, 16);
|
|
return FFI_OK;
|
}
|
|
void ffi_prep_args(extended_cif *ecif, unsigned char* stack)
|
{
|
unsigned int i;
|
unsigned long *addr;
|
ffi_type **ptr;
|
|
union {
|
void **v;
|
char **c;
|
signed char **sc;
|
unsigned char **uc;
|
signed short **ss;
|
unsigned short **us;
|
unsigned int **i;
|
long long **ll;
|
float **f;
|
double **d;
|
} p_argv;
|
|
/* Verify that everything is aligned up properly */
|
FFI_ASSERT (((unsigned long) stack & 0x7) == 0);
|
|
p_argv.v = ecif->avalue;
|
addr = (unsigned long*)stack;
|
|
/* structures with a size greater than 16 bytes are passed in memory */
|
if (ecif->cif->rtype->type == FFI_TYPE_STRUCT && ecif->cif->rtype->size > 16)
|
{
|
*addr++ = (unsigned long)ecif->rvalue;
|
}
|
|
for (i = ecif->cif->nargs, ptr = ecif->cif->arg_types;
|
i > 0;
|
i--, ptr++, p_argv.v++)
|
{
|
switch ((*ptr)->type)
|
{
|
case FFI_TYPE_SINT8:
|
*addr++ = **p_argv.sc;
|
break;
|
case FFI_TYPE_UINT8:
|
*addr++ = **p_argv.uc;
|
break;
|
case FFI_TYPE_SINT16:
|
*addr++ = **p_argv.ss;
|
break;
|
case FFI_TYPE_UINT16:
|
*addr++ = **p_argv.us;
|
break;
|
case FFI_TYPE_FLOAT:
|
case FFI_TYPE_INT:
|
case FFI_TYPE_UINT32:
|
case FFI_TYPE_SINT32:
|
case FFI_TYPE_POINTER:
|
*addr++ = **p_argv.i;
|
break;
|
case FFI_TYPE_DOUBLE:
|
case FFI_TYPE_UINT64:
|
case FFI_TYPE_SINT64:
|
if (((unsigned long)addr & 4) != 0)
|
addr++;
|
*(unsigned long long*)addr = **p_argv.ll;
|
addr += sizeof(unsigned long long) / sizeof (addr);
|
break;
|
|
case FFI_TYPE_STRUCT:
|
{
|
unsigned long offs;
|
unsigned long size;
|
|
if (((unsigned long)addr & 4) != 0 && (*ptr)->alignment > 4)
|
addr++;
|
|
offs = (unsigned long) addr - (unsigned long) stack;
|
size = (*ptr)->size;
|
|
/* Entire structure must fit the argument registers or referenced */
|
if (offs < FFI_REGISTER_NARGS * 4
|
&& offs + size > FFI_REGISTER_NARGS * 4)
|
addr = (unsigned long*) (stack + FFI_REGISTER_NARGS * 4);
|
|
memcpy((char*) addr, *p_argv.c, size);
|
addr += (size + 3) / 4;
|
break;
|
}
|
|
default:
|
FFI_ASSERT(0);
|
}
|
}
|
}
|
|
|
void ffi_call(ffi_cif* cif, void(*fn)(void), void *rvalue, void **avalue)
|
{
|
extended_cif ecif;
|
unsigned long rsize = cif->rtype->size;
|
int flags = cif->flags;
|
void *alloc = NULL;
|
|
ecif.cif = cif;
|
ecif.avalue = avalue;
|
|
/* Note that for structures that are returned in registers (size <= 16 bytes)
|
we allocate a temporary buffer and use memcpy to copy it to the final
|
destination. The reason is that the target address might be misaligned or
|
the length not a multiple of 4 bytes. Handling all those cases would be
|
very complex. */
|
|
if (flags == FFI_TYPE_STRUCT && (rsize <= 16 || rvalue == NULL))
|
{
|
alloc = alloca(ALIGN(rsize, 4));
|
ecif.rvalue = alloc;
|
}
|
else
|
{
|
ecif.rvalue = rvalue;
|
}
|
|
if (cif->abi != FFI_SYSV)
|
FFI_ASSERT(0);
|
|
ffi_call_SYSV (ecif.rvalue, rsize, cif->flags, fn, cif->bytes, &ecif);
|
|
if (alloc != NULL && rvalue != NULL)
|
memcpy(rvalue, alloc, rsize);
|
}
|
|
extern void ffi_trampoline();
|
extern void ffi_cacheflush(void* start, void* end);
|
|
ffi_status
|
ffi_prep_closure_loc (ffi_closure* closure,
|
ffi_cif* cif,
|
void (*fun)(ffi_cif*, void*, void**, void*),
|
void *user_data,
|
void *codeloc)
|
{
|
/* copye trampoline to stack and patch 'ffi_closure_SYSV' pointer */
|
memcpy(closure->tramp, ffi_trampoline, FFI_TRAMPOLINE_SIZE);
|
*(unsigned int*)(&closure->tramp[8]) = (unsigned int)ffi_closure_SYSV;
|
|
// Do we have this function?
|
// __builtin___clear_cache(closer->tramp, closer->tramp + FFI_TRAMPOLINE_SIZE)
|
ffi_cacheflush(closure->tramp, closure->tramp + FFI_TRAMPOLINE_SIZE);
|
|
closure->cif = cif;
|
closure->fun = fun;
|
closure->user_data = user_data;
|
return FFI_OK;
|
}
|
|
|
long FFI_HIDDEN
|
ffi_closure_SYSV_inner(ffi_closure *closure, void **values, void *rvalue)
|
{
|
ffi_cif *cif;
|
ffi_type **arg_types;
|
void **avalue;
|
int i, areg;
|
|
cif = closure->cif;
|
if (cif->abi != FFI_SYSV)
|
return FFI_BAD_ABI;
|
|
areg = 0;
|
|
int rtype = cif->rtype->type;
|
if (rtype == FFI_TYPE_STRUCT && cif->rtype->size > 4 * 4)
|
{
|
rvalue = *values;
|
areg++;
|
}
|
|
cif = closure->cif;
|
arg_types = cif->arg_types;
|
avalue = alloca(cif->nargs * sizeof(void *));
|
|
for (i = 0; i < cif->nargs; i++)
|
{
|
if (arg_types[i]->alignment == 8 && (areg & 1) != 0)
|
areg++;
|
|
// skip the entry 16,a1 framework, add 16 bytes (4 registers)
|
if (areg == FFI_REGISTER_NARGS)
|
areg += 4;
|
|
if (arg_types[i]->type == FFI_TYPE_STRUCT)
|
{
|
int numregs = ((arg_types[i]->size + 3) & ~3) / 4;
|
if (areg < FFI_REGISTER_NARGS && areg + numregs > FFI_REGISTER_NARGS)
|
areg = FFI_REGISTER_NARGS + 4;
|
}
|
|
avalue[i] = &values[areg];
|
areg += (arg_types[i]->size + 3) / 4;
|
}
|
|
(closure->fun)(cif, rvalue, avalue, closure->user_data);
|
|
return rtype;
|
}
|
