1 /* ----------------------------------------------------------------------- 2 ffi.c 3 4 m68k Foreign Function Interface 5 ----------------------------------------------------------------------- */ 6 7 #include <ffi.h> 8 #include <ffi_common.h> 9 10 #include <stdlib.h> 11 #include <unistd.h> 12 #ifdef __rtems__ 13 void rtems_cache_flush_multiple_data_lines( const void *, size_t ); 14 #else 15 #include <sys/syscall.h> 16 #ifdef __MINT__ 17 #include <mint/mintbind.h> 18 #include <mint/ssystem.h> 19 #else 20 #include <asm/cachectl.h> 21 #endif 22 #endif 23 24 void ffi_call_SYSV (extended_cif *, 25 unsigned, unsigned, 26 void *, void (*fn) ()); 27 void *ffi_prep_args (void *stack, extended_cif *ecif); 28 void ffi_closure_SYSV (ffi_closure *); 29 void ffi_closure_struct_SYSV (ffi_closure *); 30 unsigned int ffi_closure_SYSV_inner (ffi_closure *closure, 31 void *resp, void *args); 32 33 /* ffi_prep_args is called by the assembly routine once stack space has 34 been allocated for the function's arguments. */ 35 36 void * 37 ffi_prep_args (void *stack, extended_cif *ecif) 38 { 39 unsigned int i; 40 void **p_argv; 41 char *argp; 42 ffi_type **p_arg; 43 void *struct_value_ptr; 44 45 argp = stack; 46 47 if ( 48 #ifdef __MINT__ 49 (ecif->cif->rtype->type == FFI_TYPE_LONGDOUBLE) || 50 #endif 51 (((ecif->cif->rtype->type == FFI_TYPE_STRUCT) 52 && !ecif->cif->flags))) 53 struct_value_ptr = ecif->rvalue; 54 else 55 struct_value_ptr = NULL; 56 57 p_argv = ecif->avalue; 58 59 for (i = ecif->cif->nargs, p_arg = ecif->cif->arg_types; 60 i != 0; 61 i--, p_arg++) 62 { 63 size_t z = (*p_arg)->size; 64 int type = (*p_arg)->type; 65 66 if (z < sizeof (int)) 67 { 68 switch (type) 69 { 70 case FFI_TYPE_SINT8: 71 *(signed int *) argp = (signed int) *(SINT8 *) *p_argv; 72 break; 73 74 case FFI_TYPE_UINT8: 75 *(unsigned int *) argp = (unsigned int) *(UINT8 *) *p_argv; 76 break; 77 78 case FFI_TYPE_SINT16: 79 *(signed int *) argp = (signed int) *(SINT16 *) *p_argv; 80 break; 81 82 case FFI_TYPE_UINT16: 83 *(unsigned int *) argp = (unsigned int) *(UINT16 *) *p_argv; 84 break; 85 86 case FFI_TYPE_STRUCT: 87 #ifdef __MINT__ 88 if (z == 1 || z == 2) 89 memcpy (argp + 2, *p_argv, z); 90 else 91 memcpy (argp, *p_argv, z); 92 #else 93 memcpy (argp + sizeof (int) - z, *p_argv, z); 94 #endif 95 break; 96 97 default: 98 FFI_ASSERT (0); 99 } 100 z = sizeof (int); 101 } 102 else 103 { 104 memcpy (argp, *p_argv, z); 105 106 /* Align if necessary. */ 107 if ((sizeof(int) - 1) & z) 108 z = ALIGN(z, sizeof(int)); 109 } 110 111 p_argv++; 112 argp += z; 113 } 114 115 return struct_value_ptr; 116 } 117 118 #define CIF_FLAGS_INT 1 119 #define CIF_FLAGS_DINT 2 120 #define CIF_FLAGS_FLOAT 4 121 #define CIF_FLAGS_DOUBLE 8 122 #define CIF_FLAGS_LDOUBLE 16 123 #define CIF_FLAGS_POINTER 32 124 #define CIF_FLAGS_STRUCT1 64 125 #define CIF_FLAGS_STRUCT2 128 126 #define CIF_FLAGS_SINT8 256 127 #define CIF_FLAGS_SINT16 512 128 129 /* Perform machine dependent cif processing */ 130 ffi_status 131 ffi_prep_cif_machdep (ffi_cif *cif) 132 { 133 /* Set the return type flag */ 134 switch (cif->rtype->type) 135 { 136 case FFI_TYPE_VOID: 137 cif->flags = 0; 138 break; 139 140 case FFI_TYPE_STRUCT: 141 if (cif->rtype->elements[0]->type == FFI_TYPE_STRUCT && 142 cif->rtype->elements[1]) 143 { 144 cif->flags = 0; 145 break; 146 } 147 148 switch (cif->rtype->size) 149 { 150 case 1: 151 #ifdef __MINT__ 152 cif->flags = CIF_FLAGS_STRUCT2; 153 #else 154 cif->flags = CIF_FLAGS_STRUCT1; 155 #endif 156 break; 157 case 2: 158 cif->flags = CIF_FLAGS_STRUCT2; 159 break; 160 #ifdef __MINT__ 161 case 3: 162 #endif 163 case 4: 164 cif->flags = CIF_FLAGS_INT; 165 break; 166 #ifdef __MINT__ 167 case 7: 168 #endif 169 case 8: 170 cif->flags = CIF_FLAGS_DINT; 171 break; 172 default: 173 cif->flags = 0; 174 break; 175 } 176 break; 177 178 case FFI_TYPE_FLOAT: 179 cif->flags = CIF_FLAGS_FLOAT; 180 break; 181 182 case FFI_TYPE_DOUBLE: 183 cif->flags = CIF_FLAGS_DOUBLE; 184 break; 185 186 #if (FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE) 187 case FFI_TYPE_LONGDOUBLE: 188 #ifdef __MINT__ 189 cif->flags = 0; 190 #else 191 cif->flags = CIF_FLAGS_LDOUBLE; 192 #endif 193 break; 194 #endif 195 196 case FFI_TYPE_POINTER: 197 cif->flags = CIF_FLAGS_POINTER; 198 break; 199 200 case FFI_TYPE_SINT64: 201 case FFI_TYPE_UINT64: 202 cif->flags = CIF_FLAGS_DINT; 203 break; 204 205 case FFI_TYPE_SINT16: 206 cif->flags = CIF_FLAGS_SINT16; 207 break; 208 209 case FFI_TYPE_SINT8: 210 cif->flags = CIF_FLAGS_SINT8; 211 break; 212 213 default: 214 cif->flags = CIF_FLAGS_INT; 215 break; 216 } 217 218 return FFI_OK; 219 } 220 221 void 222 ffi_call (ffi_cif *cif, void (*fn) (), void *rvalue, void **avalue) 223 { 224 extended_cif ecif; 225 226 ecif.cif = cif; 227 ecif.avalue = avalue; 228 229 /* If the return value is a struct and we don't have a return value 230 address then we need to make one. */ 231 232 if (rvalue == NULL 233 && cif->rtype->type == FFI_TYPE_STRUCT 234 && cif->rtype->size > 8) 235 ecif.rvalue = alloca (cif->rtype->size); 236 else 237 ecif.rvalue = rvalue; 238 239 switch (cif->abi) 240 { 241 case FFI_SYSV: 242 ffi_call_SYSV (&ecif, cif->bytes, cif->flags, 243 ecif.rvalue, fn); 244 break; 245 246 default: 247 FFI_ASSERT (0); 248 break; 249 } 250 } 251 252 static void 253 ffi_prep_incoming_args_SYSV (char *stack, void **avalue, ffi_cif *cif) 254 { 255 unsigned int i; 256 void **p_argv; 257 char *argp; 258 ffi_type **p_arg; 259 260 argp = stack; 261 p_argv = avalue; 262 263 for (i = cif->nargs, p_arg = cif->arg_types; (i != 0); i--, p_arg++) 264 { 265 size_t z; 266 267 z = (*p_arg)->size; 268 #ifdef __MINT__ 269 if (cif->flags && 270 cif->rtype->type == FFI_TYPE_STRUCT && 271 (z == 1 || z == 2)) 272 { 273 *p_argv = (void *) (argp + 2); 274 275 z = 4; 276 } 277 else 278 if (cif->flags && 279 cif->rtype->type == FFI_TYPE_STRUCT && 280 (z == 3 || z == 4)) 281 { 282 *p_argv = (void *) (argp); 283 284 z = 4; 285 } 286 else 287 #endif 288 if (z <= 4) 289 { 290 *p_argv = (void *) (argp + 4 - z); 291 292 z = 4; 293 } 294 else 295 { 296 *p_argv = (void *) argp; 297 298 /* Align if necessary */ 299 if ((sizeof(int) - 1) & z) 300 z = ALIGN(z, sizeof(int)); 301 } 302 303 p_argv++; 304 argp += z; 305 } 306 } 307 308 unsigned int 309 ffi_closure_SYSV_inner (ffi_closure *closure, void *resp, void *args) 310 { 311 ffi_cif *cif; 312 void **arg_area; 313 314 cif = closure->cif; 315 arg_area = (void**) alloca (cif->nargs * sizeof (void *)); 316 317 ffi_prep_incoming_args_SYSV(args, arg_area, cif); 318 319 (closure->fun) (cif, resp, arg_area, closure->user_data); 320 321 return cif->flags; 322 } 323 324 ffi_status 325 ffi_prep_closure_loc (ffi_closure* closure, 326 ffi_cif* cif, 327 void (*fun)(ffi_cif*,void*,void**,void*), 328 void *user_data, 329 void *codeloc) 330 { 331 if (cif->abi != FFI_SYSV) 332 return FFI_BAD_ABI; 333 334 *(unsigned short *)closure->tramp = 0x207c; 335 *(void **)(closure->tramp + 2) = codeloc; 336 *(unsigned short *)(closure->tramp + 6) = 0x4ef9; 337 338 if ( 339 #ifdef __MINT__ 340 (cif->rtype->type == FFI_TYPE_LONGDOUBLE) || 341 #endif 342 (((cif->rtype->type == FFI_TYPE_STRUCT) 343 && !cif->flags))) 344 *(void **)(closure->tramp + 8) = ffi_closure_struct_SYSV; 345 else 346 *(void **)(closure->tramp + 8) = ffi_closure_SYSV; 347 348 #ifdef __rtems__ 349 rtems_cache_flush_multiple_data_lines( codeloc, FFI_TRAMPOLINE_SIZE ); 350 #elif defined(__MINT__) 351 Ssystem(S_FLUSHCACHE, codeloc, FFI_TRAMPOLINE_SIZE); 352 #else 353 syscall(SYS_cacheflush, codeloc, FLUSH_SCOPE_LINE, 354 FLUSH_CACHE_BOTH, FFI_TRAMPOLINE_SIZE); 355 #endif 356 357 closure->cif = cif; 358 closure->user_data = user_data; 359 closure->fun = fun; 360 361 return FFI_OK; 362 } 363
