1 /* ----------------------------------------------------------------------- 2 ffi.c - Copyright (c) 2003, 2004, 2006, 2007, 2012 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 void ffi_prep_args(char *stack, extended_cif *ecif) 60 { 61 register unsigned int i; 62 register unsigned int avn; 63 register void **p_argv; 64 register char *argp; 65 register ffi_type **p_arg; 66 67 argp = stack; 68 69 if (return_type (ecif->cif->rtype) == FFI_TYPE_STRUCT) 70 { 71 *(void **) argp = ecif->rvalue; 72 argp += sizeof (UINT64); 73 } 74 75 avn = ecif->cif->nargs; 76 p_argv = ecif->avalue; 77 78 for (i = 0, p_arg = ecif->cif->arg_types; i < avn; i++, p_arg++, p_argv++) 79 { 80 size_t z; 81 int align; 82 83 z = (*p_arg)->size; 84 align = (*p_arg)->alignment; 85 if (z < sizeof (UINT32)) 86 { 87 switch ((*p_arg)->type) 88 { 89 case FFI_TYPE_SINT8: 90 *(SINT64 *) argp = (SINT64) *(SINT8 *)(*p_argv); 91 break; 92 93 case FFI_TYPE_UINT8: 94 *(UINT64 *) argp = (UINT64) *(UINT8 *)(*p_argv); 95 break; 96 97 case FFI_TYPE_SINT16: 98 *(SINT64 *) argp = (SINT64) *(SINT16 *)(*p_argv); 99 break; 100 101 case FFI_TYPE_UINT16: 102 *(UINT64 *) argp = (UINT64) *(UINT16 *)(*p_argv); 103 break; 104 105 case FFI_TYPE_STRUCT: 106 memcpy (argp, *p_argv, z); 107 break; 108 109 default: 110 FFI_ASSERT(0); 111 } 112 argp += sizeof (UINT64); 113 } 114 else if (z == sizeof (UINT32) && align == sizeof (UINT32)) 115 { 116 switch ((*p_arg)->type) 117 { 118 case FFI_TYPE_INT: 119 case FFI_TYPE_SINT32: 120 *(SINT64 *) argp = (SINT64) *(SINT32 *) (*p_argv); 121 break; 122 123 case FFI_TYPE_FLOAT: 124 case FFI_TYPE_POINTER: 125 case FFI_TYPE_UINT32: 126 case FFI_TYPE_STRUCT: 127 *(UINT64 *) argp = (UINT64) *(UINT32 *) (*p_argv); 128 break; 129 130 default: 131 FFI_ASSERT(0); 132 break; 133 } 134 argp += sizeof (UINT64); 135 } 136 else if (z == sizeof (UINT64) 137 && align == sizeof (UINT64) 138 && ((int) *p_argv & (sizeof (UINT64) - 1)) == 0) 139 { 140 *(UINT64 *) argp = *(UINT64 *) (*p_argv); 141 argp += sizeof (UINT64); 142 } 143 else 144 { 145 int n = (z + sizeof (UINT64) - 1) / sizeof (UINT64); 146 147 memcpy (argp, *p_argv, z); 148 argp += n * sizeof (UINT64); 149 } 150 } 151 152 return; 153 } 154 155 /* Perform machine dependent cif processing */ 156 ffi_status ffi_prep_cif_machdep(ffi_cif *cif) 157 { 158 int i, j; 159 int size, type; 160 int n, m; 161 int greg; 162 int freg; 163 int fpair = -1; 164 165 greg = (return_type (cif->rtype) == FFI_TYPE_STRUCT ? 1 : 0); 166 freg = 0; 167 cif->flags2 = 0; 168 169 for (i = j = 0; i < cif->nargs; i++) 170 { 171 type = (cif->arg_types)[i]->type; 172 switch (type) 173 { 174 case FFI_TYPE_FLOAT: 175 greg++; 176 cif->bytes += sizeof (UINT64) - sizeof (float); 177 if (freg >= NFREGARG - 1) 178 continue; 179 if (fpair < 0) 180 { 181 fpair = freg; 182 freg += 2; 183 } 184 else 185 fpair = -1; 186 cif->flags2 += ((cif->arg_types)[i]->type) << (2 * j++); 187 break; 188 189 case FFI_TYPE_DOUBLE: 190 if (greg++ >= NGREGARG && (freg + 1) >= NFREGARG) 191 continue; 192 if ((freg + 1) < NFREGARG) 193 { 194 freg += 2; 195 cif->flags2 += ((cif->arg_types)[i]->type) << (2 * j++); 196 } 197 else 198 cif->flags2 += FFI_TYPE_INT << (2 * j++); 199 break; 200 201 default: 202 size = (cif->arg_types)[i]->size; 203 if (size < sizeof (UINT64)) 204 cif->bytes += sizeof (UINT64) - size; 205 n = (size + sizeof (UINT64) - 1) / sizeof (UINT64); 206 if (greg >= NGREGARG) 207 continue; 208 else if (greg + n - 1 >= NGREGARG) 209 greg = NGREGARG; 210 else 211 greg += n; 212 for (m = 0; m < n; m++) 213 cif->flags2 += FFI_TYPE_INT << (2 * j++); 214 break; 215 } 216 } 217 218 /* Set the return type flag */ 219 switch (cif->rtype->type) 220 { 221 case FFI_TYPE_STRUCT: 222 cif->flags = return_type (cif->rtype); 223 break; 224 225 case FFI_TYPE_VOID: 226 case FFI_TYPE_FLOAT: 227 case FFI_TYPE_DOUBLE: 228 case FFI_TYPE_SINT64: 229 case FFI_TYPE_UINT64: 230 cif->flags = cif->rtype->type; 231 break; 232 233 default: 234 cif->flags = FFI_TYPE_INT; 235 break; 236 } 237 238 return FFI_OK; 239 } 240 241 /*@-declundef@*/ 242 /*@-exportheader@*/ 243 extern void ffi_call_SYSV(void (*)(char *, extended_cif *), 244 /*@out@*/ extended_cif *, 245 unsigned, unsigned, long long, 246 /*@out@*/ unsigned *, 247 void (*fn)(void)); 248 /*@=declundef@*/ 249 /*@=exportheader@*/ 250 251 void ffi_call(/*@dependent@*/ ffi_cif *cif, 252 void (*fn)(void), 253 /*@out@*/ void *rvalue, 254 /*@dependent@*/ void **avalue) 255 { 256 extended_cif ecif; 257 UINT64 trvalue; 258 259 ecif.cif = cif; 260 ecif.avalue = avalue; 261 262 /* If the return value is a struct and we don't have a return */ 263 /* value address then we need to make one */ 264 265 if (cif->rtype->type == FFI_TYPE_STRUCT 266 && return_type (cif->rtype) != FFI_TYPE_STRUCT) 267 ecif.rvalue = &trvalue; 268 else if ((rvalue == NULL) && 269 (cif->rtype->type == FFI_TYPE_STRUCT)) 270 { 271 ecif.rvalue = alloca(cif->rtype->size); 272 } 273 else 274 ecif.rvalue = rvalue; 275 276 switch (cif->abi) 277 { 278 case FFI_SYSV: 279 ffi_call_SYSV(ffi_prep_args, &ecif, cif->bytes, cif->flags, cif->flags2, 280 ecif.rvalue, fn); 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_loc (ffi_closure *closure, 298 ffi_cif *cif, 299 void (*fun)(ffi_cif*, void*, void**, void*), 300 void *user_data, 301 void *codeloc) 302 { 303 unsigned int *tramp; 304 305 if (cif->abi != FFI_SYSV) 306 return FFI_BAD_ABI; 307 308 tramp = (unsigned int *) &closure->tramp[0]; 309 /* Since ffi_closure is an aligned object, the ffi trampoline is 310 called as an SHcompact code. Sigh. 311 SHcompact part: 312 mova @(1,pc),r0; add #1,r0; jmp @r0; nop; 313 SHmedia part: 314 movi fnaddr >> 16,r1; shori fnaddr,r1; ptabs/l r1,tr0 315 movi cxt >> 16,r1; shori cxt,r1; blink tr0,r63 */ 316 #ifdef __LITTLE_ENDIAN__ 317 tramp[0] = 0x7001c701; 318 tramp[1] = 0x0009402b; 319 #else 320 tramp[0] = 0xc7017001; 321 tramp[1] = 0x402b0009; 322 #endif 323 tramp[2] = 0xcc000010 | (((UINT32) ffi_closure_SYSV) >> 16) << 10; 324 tramp[3] = 0xc8000010 | (((UINT32) ffi_closure_SYSV) & 0xffff) << 10; 325 tramp[4] = 0x6bf10600; 326 tramp[5] = 0xcc000010 | (((UINT32) codeloc) >> 16) << 10; 327 tramp[6] = 0xc8000010 | (((UINT32) codeloc) & 0xffff) << 10; 328 tramp[7] = 0x4401fff0; 329 330 closure->cif = cif; 331 closure->fun = fun; 332 closure->user_data = user_data; 333 334 /* Flush the icache. */ 335 asm volatile ("ocbwb %0,0; synco; icbi %1,0; synci" : : "r" (tramp), 336 "r"(codeloc)); 337 338 return FFI_OK; 339 } 340 341 /* Basically the trampoline invokes ffi_closure_SYSV, and on 342 * entry, r3 holds the address of the closure. 343 * After storing the registers that could possibly contain 344 * parameters to be passed into the stack frame and setting 345 * up space for a return value, ffi_closure_SYSV invokes the 346 * following helper function to do most of the work. 347 */ 348 349 int 350 ffi_closure_helper_SYSV (ffi_closure *closure, UINT64 *rvalue, 351 UINT64 *pgr, UINT64 *pfr, UINT64 *pst) 352 { 353 void **avalue; 354 ffi_type **p_arg; 355 int i, avn; 356 int greg, freg; 357 ffi_cif *cif; 358 int fpair = -1; 359 360 cif = closure->cif; 361 avalue = alloca (cif->nargs * sizeof (void *)); 362 363 /* Copy the caller's structure return value address so that the closure 364 returns the data directly to the caller. */ 365 if (return_type (cif->rtype) == FFI_TYPE_STRUCT) 366 { 367 rvalue = (UINT64 *) *pgr; 368 greg = 1; 369 } 370 else 371 greg = 0; 372 373 freg = 0; 374 cif = closure->cif; 375 avn = cif->nargs; 376 377 /* Grab the addresses of the arguments from the stack frame. */ 378 for (i = 0, p_arg = cif->arg_types; i < avn; i++, p_arg++) 379 { 380 size_t z; 381 void *p; 382 383 z = (*p_arg)->size; 384 if (z < sizeof (UINT32)) 385 { 386 p = pgr + greg++; 387 388 switch ((*p_arg)->type) 389 { 390 case FFI_TYPE_SINT8: 391 case FFI_TYPE_UINT8: 392 case FFI_TYPE_SINT16: 393 case FFI_TYPE_UINT16: 394 case FFI_TYPE_STRUCT: 395 #ifdef __LITTLE_ENDIAN__ 396 avalue[i] = p; 397 #else 398 avalue[i] = ((char *) p) + sizeof (UINT32) - z; 399 #endif 400 break; 401 402 default: 403 FFI_ASSERT(0); 404 } 405 } 406 else if (z == sizeof (UINT32)) 407 { 408 if ((*p_arg)->type == FFI_TYPE_FLOAT) 409 { 410 if (freg < NFREGARG - 1) 411 { 412 if (fpair >= 0) 413 { 414 avalue[i] = (UINT32 *) pfr + fpair; 415 fpair = -1; 416 } 417 else 418 { 419 #ifdef __LITTLE_ENDIAN__ 420 fpair = freg; 421 avalue[i] = (UINT32 *) pfr + (1 ^ freg); 422 #else 423 fpair = 1 ^ freg; 424 avalue[i] = (UINT32 *) pfr + freg; 425 #endif 426 freg += 2; 427 } 428 } 429 else 430 #ifdef __LITTLE_ENDIAN__ 431 avalue[i] = pgr + greg; 432 #else 433 avalue[i] = (UINT32 *) (pgr + greg) + 1; 434 #endif 435 } 436 else 437 #ifdef __LITTLE_ENDIAN__ 438 avalue[i] = pgr + greg; 439 #else 440 avalue[i] = (UINT32 *) (pgr + greg) + 1; 441 #endif 442 greg++; 443 } 444 else if ((*p_arg)->type == FFI_TYPE_DOUBLE) 445 { 446 if (freg + 1 >= NFREGARG) 447 avalue[i] = pgr + greg; 448 else 449 { 450 avalue[i] = pfr + (freg >> 1); 451 freg += 2; 452 } 453 greg++; 454 } 455 else 456 { 457 int n = (z + sizeof (UINT64) - 1) / sizeof (UINT64); 458 459 avalue[i] = pgr + greg; 460 greg += n; 461 } 462 } 463 464 (closure->fun) (cif, rvalue, avalue, closure->user_data); 465 466 /* Tell ffi_closure_SYSV how to perform return type promotions. */ 467 return return_type (cif->rtype); 468 } 469 470
