1 /* ----------------------------------------------------------------------- 2 ffi.c - Copyright (c) 2003, 2004 Kaz Kojima 3 Copyright (c) 2008 Anthony Green 4 5 SuperH SHmedia Foreign Function Interface 6 7 Permission is hereby granted, free of charge, to any person obtaining 8 a copy of this software and associated documentation files (the 9 ``Software''), to deal in the Software without restriction, including 10 without limitation the rights to use, copy, modify, merge, publish, 11 distribute, sublicense, and/or sell copies of the Software, and to 12 permit persons to whom the Software is furnished to do so, subject to 13 the following conditions: 14 15 The above copyright notice and this permission notice shall be included 16 in all copies or substantial portions of the Software. 17 18 THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, 19 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 20 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 21 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 22 HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 23 WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 24 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 25 DEALINGS IN THE SOFTWARE. 26 ----------------------------------------------------------------------- */ 27 28 #include <ffi.h> 29 #include <ffi_common.h> 30 31 #include <stdlib.h> 32 33 #define NGREGARG 8 34 #define NFREGARG 12 35 36 static int 37 return_type (ffi_type *arg) 38 { 39 40 if (arg->type != FFI_TYPE_STRUCT) 41 return arg->type; 42 43 /* gcc uses r2 if the result can be packed in on register. */ 44 if (arg->size <= sizeof (UINT8)) 45 return FFI_TYPE_UINT8; 46 else if (arg->size <= sizeof (UINT16)) 47 return FFI_TYPE_UINT16; 48 else if (arg->size <= sizeof (UINT32)) 49 return FFI_TYPE_UINT32; 50 else if (arg->size <= sizeof (UINT64)) 51 return FFI_TYPE_UINT64; 52 53 return FFI_TYPE_STRUCT; 54 } 55 56 /* ffi_prep_args is called by the assembly routine once stack space 57 has been allocated for the function's arguments */ 58 59 /*@-exportheader@*/ 60 void ffi_prep_args(char *stack, extended_cif *ecif) 61 /*@=exportheader@*/ 62 { 63 register unsigned int i; 64 register unsigned int avn; 65 register void **p_argv; 66 register char *argp; 67 register ffi_type **p_arg; 68 69 argp = stack; 70 71 if (return_type (ecif->cif->rtype) == FFI_TYPE_STRUCT) 72 { 73 *(void **) argp = ecif->rvalue; 74 argp += sizeof (UINT64); 75 } 76 77 avn = ecif->cif->nargs; 78 p_argv = ecif->avalue; 79 80 for (i = 0, p_arg = ecif->cif->arg_types; i < avn; i++, p_arg++, p_argv++) 81 { 82 size_t z; 83 int align; 84 85 z = (*p_arg)->size; 86 align = (*p_arg)->alignment; 87 if (z < sizeof (UINT32)) 88 { 89 switch ((*p_arg)->type) 90 { 91 case FFI_TYPE_SINT8: 92 *(SINT64 *) argp = (SINT64) *(SINT8 *)(*p_argv); 93 break; 94 95 case FFI_TYPE_UINT8: 96 *(UINT64 *) argp = (UINT64) *(UINT8 *)(*p_argv); 97 break; 98 99 case FFI_TYPE_SINT16: 100 *(SINT64 *) argp = (SINT64) *(SINT16 *)(*p_argv); 101 break; 102 103 case FFI_TYPE_UINT16: 104 *(UINT64 *) argp = (UINT64) *(UINT16 *)(*p_argv); 105 break; 106 107 case FFI_TYPE_STRUCT: 108 memcpy (argp, *p_argv, z); 109 break; 110 111 default: 112 FFI_ASSERT(0); 113 } 114 argp += sizeof (UINT64); 115 } 116 else if (z == sizeof (UINT32) && align == sizeof (UINT32)) 117 { 118 switch ((*p_arg)->type) 119 { 120 case FFI_TYPE_INT: 121 case FFI_TYPE_SINT32: 122 *(SINT64 *) argp = (SINT64) *(SINT32 *) (*p_argv); 123 break; 124 125 case FFI_TYPE_FLOAT: 126 case FFI_TYPE_POINTER: 127 case FFI_TYPE_UINT32: 128 case FFI_TYPE_STRUCT: 129 *(UINT64 *) argp = (UINT64) *(UINT32 *) (*p_argv); 130 break; 131 132 default: 133 FFI_ASSERT(0); 134 break; 135 } 136 argp += sizeof (UINT64); 137 } 138 else if (z == sizeof (UINT64) 139 && align == sizeof (UINT64) 140 && ((int) *p_argv & (sizeof (UINT64) - 1)) == 0) 141 { 142 *(UINT64 *) argp = *(UINT64 *) (*p_argv); 143 argp += sizeof (UINT64); 144 } 145 else 146 { 147 int n = (z + sizeof (UINT64) - 1) / sizeof (UINT64); 148 149 memcpy (argp, *p_argv, z); 150 argp += n * sizeof (UINT64); 151 } 152 } 153 154 return; 155 } 156 157 /* Perform machine dependent cif processing */ 158 ffi_status ffi_prep_cif_machdep(ffi_cif *cif) 159 { 160 int i, j; 161 int size, type; 162 int n, m; 163 int greg; 164 int freg; 165 166 greg = (return_type (cif->rtype) == FFI_TYPE_STRUCT ? 1 : 0); 167 freg = 0; 168 cif->flags2 = 0; 169 170 for (i = j = 0; i < cif->nargs; i++) 171 { 172 type = (cif->arg_types)[i]->type; 173 switch (type) 174 { 175 case FFI_TYPE_FLOAT: 176 greg++; 177 cif->bytes += sizeof (UINT64) - sizeof (float); 178 if (freg >= NFREGARG - 1) 179 continue; 180 freg++; 181 cif->flags2 += ((cif->arg_types)[i]->type) << (2 * j++); 182 break; 183 184 case FFI_TYPE_DOUBLE: 185 if (greg++ >= NGREGARG && (freg + 1) >= NFREGARG) 186 continue; 187 if ((freg + 1) < NFREGARG) 188 { 189 freg = (freg + 1) & ~1; 190 freg += 2; 191 cif->flags2 += ((cif->arg_types)[i]->type) << (2 * j++); 192 } 193 else 194 cif->flags2 += FFI_TYPE_INT << (2 * j++); 195 break; 196 197 default: 198 size = (cif->arg_types)[i]->size; 199 if (size < sizeof (UINT64)) 200 cif->bytes += sizeof (UINT64) - size; 201 n = (size + sizeof (UINT64) - 1) / sizeof (UINT64); 202 if (greg >= NGREGARG) 203 continue; 204 else if (greg + n - 1 >= NGREGARG) 205 greg = NGREGARG; 206 else 207 greg += n; 208 for (m = 0; m < n; m++) 209 cif->flags2 += FFI_TYPE_INT << (2 * j++); 210 break; 211 } 212 } 213 214 /* Set the return type flag */ 215 switch (cif->rtype->type) 216 { 217 case FFI_TYPE_STRUCT: 218 cif->flags = return_type (cif->rtype); 219 break; 220 221 case FFI_TYPE_VOID: 222 case FFI_TYPE_FLOAT: 223 case FFI_TYPE_DOUBLE: 224 case FFI_TYPE_SINT64: 225 case FFI_TYPE_UINT64: 226 cif->flags = cif->rtype->type; 227 break; 228 229 default: 230 cif->flags = FFI_TYPE_INT; 231 break; 232 } 233 234 return FFI_OK; 235 } 236 237 /*@-declundef@*/ 238 /*@-exportheader@*/ 239 extern void ffi_call_SYSV(void (*)(char *, extended_cif *), 240 /*@out@*/ extended_cif *, 241 unsigned, unsigned, long long, 242 /*@out@*/ unsigned *, 243 void (*fn)(void)); 244 /*@=declundef@*/ 245 /*@=exportheader@*/ 246 247 void ffi_call(/*@dependent@*/ ffi_cif *cif, 248 void (*fn)(void), 249 /*@out@*/ void *rvalue, 250 /*@dependent@*/ void **avalue) 251 { 252 extended_cif ecif; 253 UINT64 trvalue; 254 255 ecif.cif = cif; 256 ecif.avalue = avalue; 257 258 /* If the return value is a struct and we don't have a return */ 259 /* value address then we need to make one */ 260 261 if (cif->rtype->type == FFI_TYPE_STRUCT 262 && return_type (cif->rtype) != FFI_TYPE_STRUCT) 263 ecif.rvalue = &trvalue; 264 else if ((rvalue == NULL) && 265 (cif->rtype->type == FFI_TYPE_STRUCT)) 266 { 267 /*@-sysunrecog@*/ 268 ecif.rvalue = alloca(cif->rtype->size); 269 /*@=sysunrecog@*/ 270 } 271 else 272 ecif.rvalue = rvalue; 273 274 switch (cif->abi) 275 { 276 case FFI_SYSV: 277 /*@-usedef@*/ 278 ffi_call_SYSV(ffi_prep_args, &ecif, cif->bytes, 279 cif->flags, cif->flags2, ecif.rvalue, fn); 280 /*@=usedef@*/ 281 break; 282 default: 283 FFI_ASSERT(0); 284 break; 285 } 286 287 if (rvalue 288 && cif->rtype->type == FFI_TYPE_STRUCT 289 && return_type (cif->rtype) != FFI_TYPE_STRUCT) 290 memcpy (rvalue, &trvalue, cif->rtype->size); 291 } 292 293 extern void ffi_closure_SYSV (void); 294 extern void __ic_invalidate (void *line); 295 296 ffi_status 297 ffi_prep_closure (ffi_closure *closure, 298 ffi_cif *cif, 299 void (*fun)(ffi_cif*, void*, void**, void*), 300 void *user_data) 301 { 302 unsigned int *tramp; 303 304 FFI_ASSERT (cif->abi == FFI_GCC_SYSV); 305 306 tramp = (unsigned int *) &closure->tramp[0]; 307 /* Since ffi_closure is an aligned object, the ffi trampoline is 308 called as an SHcompact code. Sigh. 309 SHcompact part: 310 mova @(1,pc),r0; add #1,r0; jmp @r0; nop; 311 SHmedia part: 312 movi fnaddr >> 16,r1; shori fnaddr,r1; ptabs/l r1,tr0 313 movi cxt >> 16,r1; shori cxt,r1; blink tr0,r63 */ 314 #ifdef __LITTLE_ENDIAN__ 315 tramp[0] = 0x7001c701; 316 tramp[1] = 0x0009402b; 317 #else 318 tramp[0] = 0xc7017001; 319 tramp[1] = 0x402b0009; 320 #endif 321 tramp[2] = 0xcc000010 | (((UINT32) ffi_closure_SYSV) >> 16) << 10; 322 tramp[3] = 0xc8000010 | (((UINT32) ffi_closure_SYSV) & 0xffff) << 10; 323 tramp[4] = 0x6bf10600; 324 tramp[5] = 0xcc000010 | (((UINT32) closure) >> 16) << 10; 325 tramp[6] = 0xc8000010 | (((UINT32) closure) & 0xffff) << 10; 326 tramp[7] = 0x4401fff0; 327 328 closure->cif = cif; 329 closure->fun = fun; 330 closure->user_data = user_data; 331 332 /* Flush the icache. */ 333 asm volatile ("ocbwb %0,0; synco; icbi %0,0; synci" : : "r" (tramp)); 334 335 return FFI_OK; 336 } 337 338 /* Basically the trampoline invokes ffi_closure_SYSV, and on 339 * entry, r3 holds the address of the closure. 340 * After storing the registers that could possibly contain 341 * parameters to be passed into the stack frame and setting 342 * up space for a return value, ffi_closure_SYSV invokes the 343 * following helper function to do most of the work. 344 */ 345 346 int 347 ffi_closure_helper_SYSV (ffi_closure *closure, UINT64 *rvalue, 348 UINT64 *pgr, UINT64 *pfr, UINT64 *pst) 349 { 350 void **avalue; 351 ffi_type **p_arg; 352 int i, avn; 353 int greg, freg; 354 ffi_cif *cif; 355 356 cif = closure->cif; 357 avalue = alloca (cif->nargs * sizeof (void *)); 358 359 /* Copy the caller's structure return value address so that the closure 360 returns the data directly to the caller. */ 361 if (return_type (cif->rtype) == FFI_TYPE_STRUCT) 362 { 363 rvalue = *pgr; 364 greg = 1; 365 } 366 else 367 greg = 0; 368 369 freg = 0; 370 cif = closure->cif; 371 avn = cif->nargs; 372 373 /* Grab the addresses of the arguments from the stack frame. */ 374 for (i = 0, p_arg = cif->arg_types; i < avn; i++, p_arg++) 375 { 376 size_t z; 377 void *p; 378 379 z = (*p_arg)->size; 380 if (z < sizeof (UINT32)) 381 { 382 p = pgr + greg++; 383 384 switch ((*p_arg)->type) 385 { 386 case FFI_TYPE_SINT8: 387 case FFI_TYPE_UINT8: 388 case FFI_TYPE_SINT16: 389 case FFI_TYPE_UINT16: 390 case FFI_TYPE_STRUCT: 391 #ifdef __LITTLE_ENDIAN__ 392 avalue[i] = p; 393 #else 394 avalue[i] = ((char *) p) + sizeof (UINT32) - z; 395 #endif 396 break; 397 398 default: 399 FFI_ASSERT(0); 400 } 401 } 402 else if (z == sizeof (UINT32)) 403 { 404 if ((*p_arg)->type == FFI_TYPE_FLOAT) 405 { 406 if (freg < NFREGARG - 1) 407 #ifdef __LITTLE_ENDIAN__ 408 avalue[i] = (UINT32 *) pfr + (1 ^ freg++); 409 #else 410 avalue[i] = (UINT32 *) pfr + freg++; 411 #endif 412 else 413 #ifdef __LITTLE_ENDIAN__ 414 avalue[i] = pgr + greg; 415 #else 416 avalue[i] = (UINT32 *) (pgr + greg) + 1; 417 #endif 418 } 419 else 420 #ifdef __LITTLE_ENDIAN__ 421 avalue[i] = pgr + greg; 422 #else 423 avalue[i] = (UINT32 *) (pgr + greg) + 1; 424 #endif 425 greg++; 426 } 427 else if ((*p_arg)->type == FFI_TYPE_DOUBLE) 428 { 429 if (freg + 1 >= NFREGARG) 430 avalue[i] = pgr + greg; 431 else 432 { 433 freg = (freg + 1) & ~1; 434 avalue[i] = pfr + (freg >> 1); 435 freg += 2; 436 } 437 greg++; 438 } 439 else 440 { 441 int n = (z + sizeof (UINT64) - 1) / sizeof (UINT64); 442 443 avalue[i] = pgr + greg; 444 greg += n; 445 } 446 } 447 448 (closure->fun) (cif, rvalue, avalue, closure->user_data); 449 450 /* Tell ffi_closure_SYSV how to perform return type promotions. */ 451 return return_type (cif->rtype); 452 } 453 454
