| /* ----------------------------------------------------------------------- |
| ffi.c - Copyright (c) 2011 Anthony Green |
| Copyright (c) 2009 Bradley Smith <brad@brad-smith.co.uk> |
| |
| AVR32 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> |
| #include <stdio.h> |
| #include <unistd.h> |
| #include <asm/unistd.h> |
| |
| /* #define DEBUG */ |
| |
| extern void ffi_call_SYSV(void (*)(char *, extended_cif *), extended_cif *, |
| unsigned int, unsigned int, unsigned int*, unsigned int, |
| void (*fn)(void)); |
| extern void ffi_closure_SYSV (ffi_closure *); |
| |
| unsigned int pass_struct_on_stack(ffi_type *type) |
| { |
| if(type->type != FFI_TYPE_STRUCT) |
| return 0; |
| |
| if(type->alignment < type->size && |
| !(type->size == 4 || type->size == 8) && |
| !(type->size == 8 && type->alignment >= 4)) |
| return 1; |
| |
| if(type->size == 3 || type->size == 5 || type->size == 6 || |
| type->size == 7) |
| return 1; |
| |
| return 0; |
| } |
| |
| /* ffi_prep_args is called by the assembly routine once stack space |
| * has been allocated for the function's arguments |
| * |
| * This is annoyingly complex since we need to keep track of used |
| * registers. |
| */ |
| |
| void ffi_prep_args(char *stack, extended_cif *ecif) |
| { |
| unsigned int i; |
| void **p_argv; |
| ffi_type **p_arg; |
| char *reg_base = stack; |
| char *stack_base = stack + 20; |
| unsigned int stack_offset = 0; |
| unsigned int reg_mask = 0; |
| |
| p_argv = ecif->avalue; |
| |
| /* If cif->flags is struct then we know it's not passed in registers */ |
| if(ecif->cif->flags == FFI_TYPE_STRUCT) |
| { |
| *(void**)reg_base = ecif->rvalue; |
| reg_mask |= 1; |
| } |
| |
| for(i = 0, p_arg = ecif->cif->arg_types; i < ecif->cif->nargs; |
| i++, p_arg++) |
| { |
| size_t z = (*p_arg)->size; |
| int alignment = (*p_arg)->alignment; |
| int type = (*p_arg)->type; |
| char *addr = 0; |
| |
| if(z % 4 != 0) |
| z += (4 - z % 4); |
| |
| if(reg_mask != 0x1f) |
| { |
| if(pass_struct_on_stack(*p_arg)) |
| { |
| addr = stack_base + stack_offset; |
| stack_offset += z; |
| } |
| else if(z == sizeof(int)) |
| { |
| char index = 0; |
| |
| while((reg_mask >> index) & 1) |
| index++; |
| |
| addr = reg_base + (index * 4); |
| reg_mask |= (1 << index); |
| } |
| else if(z == 2 * sizeof(int)) |
| { |
| if(!((reg_mask >> 1) & 1)) |
| { |
| addr = reg_base + 4; |
| reg_mask |= (3 << 1); |
| } |
| else if(!((reg_mask >> 3) & 1)) |
| { |
| addr = reg_base + 12; |
| reg_mask |= (3 << 3); |
| } |
| } |
| } |
| |
| if(!addr) |
| { |
| addr = stack_base + stack_offset; |
| stack_offset += z; |
| } |
| |
| if(type == FFI_TYPE_STRUCT && (*p_arg)->elements[1] == NULL) |
| type = (*p_arg)->elements[0]->type; |
| |
| switch(type) |
| { |
| case FFI_TYPE_UINT8: |
| *(unsigned int *)addr = (unsigned int)*(UINT8 *)(*p_argv); |
| break; |
| case FFI_TYPE_SINT8: |
| *(signed int *)addr = (signed int)*(SINT8 *)(*p_argv); |
| break; |
| case FFI_TYPE_UINT16: |
| *(unsigned int *)addr = (unsigned int)*(UINT16 *)(*p_argv); |
| break; |
| case FFI_TYPE_SINT16: |
| *(signed int *)addr = (signed int)*(SINT16 *)(*p_argv); |
| break; |
| default: |
| memcpy(addr, *p_argv, z); |
| } |
| |
| p_argv++; |
| } |
| |
| #ifdef DEBUG |
| /* Debugging */ |
| for(i = 0; i < 5; i++) |
| { |
| if((reg_mask & (1 << i)) == 0) |
| printf("r%d: (unused)\n", 12 - i); |
| else |
| printf("r%d: 0x%08x\n", 12 - i, ((unsigned int*)reg_base)[i]); |
| } |
| |
| for(i = 0; i < stack_offset / 4; i++) |
| { |
| printf("sp+%d: 0x%08x\n", i*4, ((unsigned int*)stack_base)[i]); |
| } |
| #endif |
| } |
| |
| /* Perform machine dependent cif processing */ |
| ffi_status ffi_prep_cif_machdep(ffi_cif *cif) |
| { |
| /* Round the stack up to a multiple of 8 bytes. This isn't needed |
| * everywhere, but it is on some platforms, and it doesn't harm |
| * anything when it isn't needed. */ |
| cif->bytes = (cif->bytes + 7) & ~7; |
| |
| /* Flag to indicate that he return value is in fact a struct */ |
| cif->rstruct_flag = 0; |
| |
| /* Set the return type flag */ |
| switch(cif->rtype->type) |
| { |
| case FFI_TYPE_SINT8: |
| case FFI_TYPE_UINT8: |
| cif->flags = (unsigned)FFI_TYPE_UINT8; |
| break; |
| case FFI_TYPE_SINT16: |
| case FFI_TYPE_UINT16: |
| cif->flags = (unsigned)FFI_TYPE_UINT16; |
| break; |
| case FFI_TYPE_FLOAT: |
| case FFI_TYPE_SINT32: |
| case FFI_TYPE_UINT32: |
| case FFI_TYPE_POINTER: |
| cif->flags = (unsigned)FFI_TYPE_UINT32; |
| break; |
| case FFI_TYPE_DOUBLE: |
| case FFI_TYPE_SINT64: |
| case FFI_TYPE_UINT64: |
| cif->flags = (unsigned)FFI_TYPE_UINT64; |
| break; |
| case FFI_TYPE_STRUCT: |
| cif->rstruct_flag = 1; |
| if(!pass_struct_on_stack(cif->rtype)) |
| { |
| if(cif->rtype->size <= 1) |
| cif->flags = (unsigned)FFI_TYPE_UINT8; |
| else if(cif->rtype->size <= 2) |
| cif->flags = (unsigned)FFI_TYPE_UINT16; |
| else if(cif->rtype->size <= 4) |
| cif->flags = (unsigned)FFI_TYPE_UINT32; |
| else if(cif->rtype->size <= 8) |
| cif->flags = (unsigned)FFI_TYPE_UINT64; |
| else |
| cif->flags = (unsigned)cif->rtype->type; |
| } |
| else |
| cif->flags = (unsigned)cif->rtype->type; |
| break; |
| default: |
| cif->flags = (unsigned)cif->rtype->type; |
| break; |
| } |
| |
| return FFI_OK; |
| } |
| |
| void ffi_call(ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue) |
| { |
| extended_cif ecif; |
| |
| unsigned int size = 0, i = 0; |
| ffi_type **p_arg; |
| |
| ecif.cif = cif; |
| ecif.avalue = avalue; |
| |
| for(i = 0, p_arg = cif->arg_types; i < cif->nargs; i++, p_arg++) |
| size += (*p_arg)->size + (4 - (*p_arg)->size % 4); |
| |
| /* If the return value is a struct and we don't have a return value |
| * address then we need to make one */ |
| |
| /* If cif->flags is struct then it's not suitable for registers */ |
| if((rvalue == NULL) && (cif->flags == FFI_TYPE_STRUCT)) |
| ecif.rvalue = alloca(cif->rtype->size); |
| else |
| ecif.rvalue = rvalue; |
| |
| switch(cif->abi) |
| { |
| case FFI_SYSV: |
| ffi_call_SYSV(ffi_prep_args, &ecif, size, cif->flags, |
| ecif.rvalue, cif->rstruct_flag, fn); |
| break; |
| default: |
| FFI_ASSERT(0); |
| break; |
| } |
| } |
| |
| static void ffi_prep_incoming_args_SYSV(char *stack, void **rvalue, |
| void **avalue, ffi_cif *cif) |
| { |
| register unsigned int i, reg_mask = 0; |
| register void **p_argv; |
| register ffi_type **p_arg; |
| register char *reg_base = stack; |
| register char *stack_base = stack + 20; |
| register unsigned int stack_offset = 0; |
| |
| #ifdef DEBUG |
| /* Debugging */ |
| for(i = 0; i < cif->nargs + 7; i++) |
| { |
| printf("sp+%d: 0x%08x\n", i*4, ((unsigned int*)stack)[i]); |
| } |
| #endif |
| |
| /* If cif->flags is struct then we know it's not passed in registers */ |
| if(cif->flags == FFI_TYPE_STRUCT) |
| { |
| *rvalue = *(void **)reg_base; |
| reg_mask |= 1; |
| } |
| |
| p_argv = avalue; |
| |
| for(i = 0, p_arg = cif->arg_types; i < cif->nargs; i++, p_arg++) |
| { |
| size_t z = (*p_arg)->size; |
| int alignment = (*p_arg)->alignment; |
| |
| *p_argv = 0; |
| |
| if(z % 4 != 0) |
| z += (4 - z % 4); |
| |
| if(reg_mask != 0x1f) |
| { |
| if(pass_struct_on_stack(*p_arg)) |
| { |
| *p_argv = (void*)stack_base + stack_offset; |
| stack_offset += z; |
| } |
| else if(z <= sizeof(int)) |
| { |
| char index = 0; |
| |
| while((reg_mask >> index) & 1) |
| index++; |
| |
| *p_argv = (void*)reg_base + (index * 4); |
| reg_mask |= (1 << index); |
| } |
| else if(z == 2 * sizeof(int)) |
| { |
| if(!((reg_mask >> 1) & 1)) |
| { |
| *p_argv = (void*)reg_base + 4; |
| reg_mask |= (3 << 1); |
| } |
| else if(!((reg_mask >> 3) & 1)) |
| { |
| *p_argv = (void*)reg_base + 12; |
| reg_mask |= (3 << 3); |
| } |
| } |
| } |
| |
| if(!*p_argv) |
| { |
| *p_argv = (void*)stack_base + stack_offset; |
| stack_offset += z; |
| } |
| |
| if((*p_arg)->type != FFI_TYPE_STRUCT || |
| (*p_arg)->elements[1] == NULL) |
| { |
| if(alignment == 1) |
| **(unsigned int**)p_argv <<= 24; |
| else if(alignment == 2) |
| **(unsigned int**)p_argv <<= 16; |
| } |
| |
| p_argv++; |
| } |
| |
| #ifdef DEBUG |
| /* Debugging */ |
| for(i = 0; i < cif->nargs; i++) |
| { |
| printf("sp+%d: 0x%08x\n", i*4, *(((unsigned int**)avalue)[i])); |
| } |
| #endif |
| } |
| |
| /* This function is jumped to by the trampoline */ |
| |
| unsigned int ffi_closure_SYSV_inner(ffi_closure *closure, void **respp, |
| void *args) |
| { |
| ffi_cif *cif; |
| void **arg_area; |
| unsigned int i, size = 0; |
| ffi_type **p_arg; |
| |
| cif = closure->cif; |
| |
| for(i = 0, p_arg = cif->arg_types; i < cif->nargs; i++, p_arg++) |
| size += (*p_arg)->size + (4 - (*p_arg)->size % 4); |
| |
| arg_area = (void **)alloca(size); |
| |
| /* 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, respp, arg_area, cif); |
| |
| (closure->fun)(cif, *respp, arg_area, closure->user_data); |
| |
| return cif->flags; |
| } |
| |
| ffi_status ffi_prep_closure_loc(ffi_closure* closure, ffi_cif* cif, |
| void (*fun)(ffi_cif*, void*, void**, void*), void *user_data, |
| void *codeloc) |
| { |
| if (cif->abi != FFI_SYSV) |
| return FFI_BAD_ABI; |
| |
| unsigned char *__tramp = (unsigned char*)(&closure->tramp[0]); |
| unsigned int __fun = (unsigned int)(&ffi_closure_SYSV); |
| unsigned int __ctx = (unsigned int)(codeloc); |
| unsigned int __rstruct_flag = (unsigned int)(cif->rstruct_flag); |
| unsigned int __inner = (unsigned int)(&ffi_closure_SYSV_inner); |
| *(unsigned int*) &__tramp[0] = 0xebcd1f00; /* pushm r8-r12 */ |
| *(unsigned int*) &__tramp[4] = 0xfefc0010; /* ld.w r12, pc[16] */ |
| *(unsigned int*) &__tramp[8] = 0xfefb0010; /* ld.w r11, pc[16] */ |
| *(unsigned int*) &__tramp[12] = 0xfefa0010; /* ld.w r10, pc[16] */ |
| *(unsigned int*) &__tramp[16] = 0xfeff0010; /* ld.w pc, pc[16] */ |
| *(unsigned int*) &__tramp[20] = __ctx; |
| *(unsigned int*) &__tramp[24] = __rstruct_flag; |
| *(unsigned int*) &__tramp[28] = __inner; |
| *(unsigned int*) &__tramp[32] = __fun; |
| syscall(__NR_cacheflush, 0, (&__tramp[0]), 36); |
| |
| closure->cif = cif; |
| closure->user_data = user_data; |
| closure->fun = fun; |
| |
| return FFI_OK; |
| } |
| |
