| 1 |
/* Copyright (c) 2020 Kalray |
| 2 |
|
| 3 |
Permission is hereby granted, free of charge, to any person obtaining |
| 4 |
a copy of this software and associated documentation files (the |
| 5 |
``Software''), to deal in the Software without restriction, including |
| 6 |
without limitation the rights to use, copy, modify, merge, publish, |
| 7 |
distribute, sublicense, and/or sell copies of the Software, and to |
| 8 |
permit persons to whom the Software is furnished to do so, subject to |
| 9 |
the following conditions: |
| 10 |
|
| 11 |
The above copyright notice and this permission notice shall be |
| 12 |
included in all copies or substantial portions of the Software. |
| 13 |
|
| 14 |
THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, |
| 15 |
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
| 16 |
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. |
| 17 |
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY |
| 18 |
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, |
| 19 |
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE |
| 20 |
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ |
| 21 |
|
| 22 |
#if defined(__kvx__) |
| 23 |
#include <stdio.h> |
| 24 |
#include <stdlib.h> |
| 25 |
#include <stdint.h> |
| 26 |
#include <fficonfig.h> |
| 27 |
#include <ffi.h> |
| 28 |
#include "ffi_common.h" |
| 29 |
#include "asm.h" |
| 30 |
|
| 31 |
#define ALIGN(x, a) ALIGN_MASK(x, (typeof(x))(a) - 1) |
| 32 |
#define ALIGN_MASK(x, mask) (((x) + (mask)) & ~(mask)) |
| 33 |
#define KVX_ABI_STACK_ALIGNMENT (32) |
| 34 |
#define KVX_ABI_STACK_ARG_ALIGNMENT (8) |
| 35 |
#define max(a,b) ((a) > (b) ? (a) : (b)) |
| 36 |
|
| 37 |
#ifdef FFI_DEBUG |
| 38 |
#define DEBUG_PRINT(...) do{ fprintf( stderr, __VA_ARGS__ ); } while(0) |
| 39 |
#else |
| 40 |
#define DEBUG_PRINT(...) |
| 41 |
#endif |
| 42 |
|
| 43 |
struct ret_value { |
| 44 |
unsigned long int r0; |
| 45 |
unsigned long int r1; |
| 46 |
unsigned long int r2; |
| 47 |
unsigned long int r3; |
| 48 |
}; |
| 49 |
|
| 50 |
extern struct ret_value ffi_call_SYSV(unsigned total_size, |
| 51 |
unsigned size, |
| 52 |
extended_cif *ecif, |
| 53 |
unsigned *rvalue_addr, |
| 54 |
void *fn, |
| 55 |
unsigned int_ext_method); |
| 56 |
|
| 57 |
/* Perform machine dependent cif processing */ |
| 58 |
ffi_status ffi_prep_cif_machdep(ffi_cif *cif) |
| 59 |
{ |
| 60 |
cif->flags = cif->rtype->size; |
| 61 |
return FFI_OK; |
| 62 |
} |
| 63 |
|
| 64 |
/* ffi_prep_args is called by the assembly routine once stack space |
| 65 |
has been allocated for the function's arguments */ |
| 66 |
|
| 67 |
void *ffi_prep_args(char *stack, unsigned int arg_slots_size, extended_cif *ecif) |
| 68 |
{ |
| 69 |
char *stacktemp = stack; |
| 70 |
char *current_arg_passed_by_value = stack + arg_slots_size; |
| 71 |
int i, s; |
| 72 |
ffi_type **arg; |
| 73 |
int count = 0; |
| 74 |
ffi_cif *cif = ecif->cif; |
| 75 |
void **argv = ecif->avalue; |
| 76 |
|
| 77 |
arg = cif->arg_types; |
| 78 |
|
| 79 |
DEBUG_PRINT("stack: %p\n", stack); |
| 80 |
DEBUG_PRINT("arg_slots_size: %u\n", arg_slots_size); |
| 81 |
DEBUG_PRINT("current_arg_passed_by_value: %p\n", current_arg_passed_by_value); |
| 82 |
DEBUG_PRINT("ecif: %p\n", ecif); |
| 83 |
DEBUG_PRINT("ecif->avalue: %p\n", ecif->avalue); |
| 84 |
|
| 85 |
for (i = 0; i < cif->nargs; i++) { |
| 86 |
|
| 87 |
s = KVX_ABI_SLOT_SIZE; |
| 88 |
switch((*arg)->type) { |
| 89 |
case FFI_TYPE_SINT8: |
| 90 |
case FFI_TYPE_UINT8: |
| 91 |
case FFI_TYPE_SINT16: |
| 92 |
case FFI_TYPE_UINT16: |
| 93 |
case FFI_TYPE_SINT32: |
| 94 |
case FFI_TYPE_UINT32: |
| 95 |
case FFI_TYPE_FLOAT: |
| 96 |
case FFI_TYPE_DOUBLE: |
| 97 |
case FFI_TYPE_UINT64: |
| 98 |
case FFI_TYPE_SINT64: |
| 99 |
case FFI_TYPE_POINTER: |
| 100 |
DEBUG_PRINT("INT64/32/16/8/FLOAT/DOUBLE or POINTER @%p\n", stack); |
| 101 |
*(uint64_t *) stack = *(uint64_t *)(* argv); |
| 102 |
break; |
| 103 |
|
| 104 |
case FFI_TYPE_COMPLEX: |
| 105 |
if ((*arg)->size == 8) |
| 106 |
*(_Complex float *) stack = *(_Complex float *)(* argv); |
| 107 |
else if ((*arg)->size == 16) { |
| 108 |
*(_Complex double *) stack = *(_Complex double *)(* argv); |
| 109 |
s = 16; |
| 110 |
} else |
| 111 |
abort(); |
| 112 |
break; |
| 113 |
case FFI_TYPE_STRUCT: { |
| 114 |
char *value; |
| 115 |
unsigned int written_size = 0; |
| 116 |
DEBUG_PRINT("struct by value @%p\n", stack); |
| 117 |
if ((*arg)->size > KVX_ABI_MAX_AGGREGATE_IN_REG_SIZE) { |
| 118 |
DEBUG_PRINT("big struct\n"); |
| 119 |
*(uint64_t *) stack = (uintptr_t)current_arg_passed_by_value; |
| 120 |
value = current_arg_passed_by_value; |
| 121 |
current_arg_passed_by_value += (*arg)->size; |
| 122 |
written_size = KVX_ABI_SLOT_SIZE; |
| 123 |
} else { |
| 124 |
value = stack; |
| 125 |
written_size = (*arg)->size; |
| 126 |
} |
| 127 |
memcpy(value, *argv, (*arg)->size); |
| 128 |
s = ALIGN(written_size, KVX_ABI_STACK_ARG_ALIGNMENT); |
| 129 |
break; |
| 130 |
} |
| 131 |
default: |
| 132 |
printf("Error: unsupported arg type %d\n", (*arg)->type); |
| 133 |
abort(); |
| 134 |
break; |
| 135 |
|
| 136 |
} |
| 137 |
stack += s; |
| 138 |
count += s; |
| 139 |
argv++; |
| 140 |
arg++; |
| 141 |
} |
| 142 |
#ifdef FFI_DEBUG |
| 143 |
FFI_ASSERT(((intptr_t)(stacktemp + REG_ARGS_SIZE) & (KVX_ABI_STACK_ALIGNMENT-1)) == 0); |
| 144 |
#endif |
| 145 |
return stacktemp + REG_ARGS_SIZE; |
| 146 |
} |
| 147 |
|
| 148 |
/* Perform machine dependent cif processing when we have a variadic function */ |
| 149 |
|
| 150 |
ffi_status ffi_prep_cif_machdep_var(ffi_cif *cif, unsigned int nfixedargs, |
| 151 |
unsigned int ntotalargs) |
| 152 |
{ |
| 153 |
cif->flags = cif->rtype->size; |
| 154 |
return FFI_OK; |
| 155 |
} |
| 156 |
|
| 157 |
static unsigned long handle_small_int_ext(kvx_intext_method *int_ext_method, |
| 158 |
const ffi_type *rtype) |
| 159 |
{ |
| 160 |
switch (rtype->type) { |
| 161 |
case FFI_TYPE_SINT8: |
| 162 |
*int_ext_method = KVX_RET_SXBD; |
| 163 |
return KVX_REGISTER_SIZE; |
| 164 |
|
| 165 |
case FFI_TYPE_SINT16: |
| 166 |
*int_ext_method = KVX_RET_SXHD; |
| 167 |
return KVX_REGISTER_SIZE; |
| 168 |
|
| 169 |
case FFI_TYPE_SINT32: |
| 170 |
*int_ext_method = KVX_RET_SXWD; |
| 171 |
return KVX_REGISTER_SIZE; |
| 172 |
|
| 173 |
case FFI_TYPE_UINT8: |
| 174 |
*int_ext_method = KVX_RET_ZXBD; |
| 175 |
return KVX_REGISTER_SIZE; |
| 176 |
|
| 177 |
case FFI_TYPE_UINT16: |
| 178 |
*int_ext_method = KVX_RET_ZXHD; |
| 179 |
return KVX_REGISTER_SIZE; |
| 180 |
|
| 181 |
case FFI_TYPE_UINT32: |
| 182 |
*int_ext_method = KVX_RET_ZXWD; |
| 183 |
return KVX_REGISTER_SIZE; |
| 184 |
|
| 185 |
default: |
| 186 |
*int_ext_method = KVX_RET_NONE; |
| 187 |
return rtype->size; |
| 188 |
} |
| 189 |
} |
| 190 |
|
| 191 |
void ffi_call(ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue) |
| 192 |
{ |
| 193 |
int i; |
| 194 |
unsigned long int slot_fitting_args_size = 0; |
| 195 |
unsigned long int total_size = 0; |
| 196 |
unsigned long int big_struct_size = 0; |
| 197 |
kvx_intext_method int_extension_method; |
| 198 |
ffi_type **arg; |
| 199 |
struct ret_value local_rvalue = {0}; |
| 200 |
size_t wb_size; |
| 201 |
|
| 202 |
|
| 203 |
/* Calculate size to allocate on stack */ |
| 204 |
for (i = 0, arg = cif->arg_types; i < cif->nargs; i++, arg++) { |
| 205 |
DEBUG_PRINT("argument %d, type %d, size %lu\n", i, (*arg)->type, (*arg)->size); |
| 206 |
if (((*arg)->type == FFI_TYPE_STRUCT) || ((*arg)->type == FFI_TYPE_COMPLEX)) { |
| 207 |
if ((*arg)->size <= KVX_ABI_MAX_AGGREGATE_IN_REG_SIZE) { |
| 208 |
slot_fitting_args_size += ALIGN((*arg)->size, KVX_ABI_SLOT_SIZE); |
| 209 |
} else { |
| 210 |
slot_fitting_args_size += KVX_ABI_SLOT_SIZE; /* aggregate passed by reference */ |
| 211 |
big_struct_size += ALIGN((*arg)->size, KVX_ABI_SLOT_SIZE); |
| 212 |
} |
| 213 |
} else if ((*arg)->size <= KVX_ABI_SLOT_SIZE) { |
| 214 |
slot_fitting_args_size += KVX_ABI_SLOT_SIZE; |
| 215 |
} else { |
| 216 |
printf("Error: unsupported arg size %ld arg type %d\n", (*arg)->size, (*arg)->type); |
| 217 |
abort(); /* should never happen? */ |
| 218 |
} |
| 219 |
} |
| 220 |
|
| 221 |
extended_cif ecif; |
| 222 |
ecif.cif = cif; |
| 223 |
ecif.avalue = avalue; |
| 224 |
ecif.rvalue = rvalue; |
| 225 |
|
| 226 |
/* This implementation allocates anyway for all register based args */ |
| 227 |
slot_fitting_args_size = max(slot_fitting_args_size, REG_ARGS_SIZE); |
| 228 |
total_size = slot_fitting_args_size + big_struct_size; |
| 229 |
total_size = ALIGN(total_size, KVX_ABI_STACK_ALIGNMENT); |
| 230 |
|
| 231 |
/* wb_size: write back size, the size we will need to write back to user |
| 232 |
* provided buffer. In theory it should always be cif->flags which is |
| 233 |
* cif->rtype->size. But libffi API mandates that for integral types |
| 234 |
* of size <= system register size, then we *MUST* write back |
| 235 |
* the size of system register size. |
| 236 |
* in our case, if size <= 8 bytes we must write back 8 bytes. |
| 237 |
* floats, complex and structs are not affected, only integrals. |
| 238 |
*/ |
| 239 |
wb_size = handle_small_int_ext(&int_extension_method, cif->rtype); |
| 240 |
|
| 241 |
switch (cif->abi) { |
| 242 |
case FFI_SYSV: |
| 243 |
DEBUG_PRINT("total_size: %lu\n", total_size); |
| 244 |
DEBUG_PRINT("slot fitting args size: %lu\n", slot_fitting_args_size); |
| 245 |
DEBUG_PRINT("rvalue: %p\n", rvalue); |
| 246 |
DEBUG_PRINT("fn: %p\n", fn); |
| 247 |
DEBUG_PRINT("rsize: %u\n", cif->flags); |
| 248 |
DEBUG_PRINT("wb_size: %u\n", wb_size); |
| 249 |
DEBUG_PRINT("int_extension_method: %u\n", int_extension_method); |
| 250 |
local_rvalue = ffi_call_SYSV(total_size, slot_fitting_args_size, |
| 251 |
&ecif, rvalue, fn, int_extension_method); |
| 252 |
if ((cif->flags <= KVX_ABI_MAX_AGGREGATE_IN_REG_SIZE) |
| 253 |
&& (cif->rtype->type != FFI_TYPE_VOID)) |
| 254 |
memcpy(rvalue, &local_rvalue, wb_size); |
| 255 |
break; |
| 256 |
default: |
| 257 |
abort(); |
| 258 |
break; |
| 259 |
} |
| 260 |
} |
| 261 |
|
| 262 |
/* Closures not supported yet */ |
| 263 |
ffi_status |
| 264 |
ffi_prep_closure_loc (ffi_closure* closure, |
| 265 |
ffi_cif* cif, |
| 266 |
void (*fun)(ffi_cif*,void*,void**,void*), |
| 267 |
void *user_data, |
| 268 |
void *codeloc) |
| 269 |
{ |
| 270 |
return FFI_BAD_ABI; |
| 271 |
} |
| 272 |
|
| 273 |
#endif /* (__kvx__) */ |