1 /* ----------------------------------------------------------------------- 2 ffi.c - Copyright (c) 1996, 1998, 1999, 2001, 2007, 2008 Red Hat, Inc. 3 Copyright (c) 2002 Ranjit Mathew 4 Copyright (c) 2002 Bo Thorsen 5 Copyright (c) 2002 Roger Sayle 6 Copyright (C) 2008 Free Software Foundation, Inc. 7 8 x86 Foreign Function Interface 9 10 Permission is hereby granted, free of charge, to any person obtaining 11 a copy of this software and associated documentation files (the 12 ``Software''), to deal in the Software without restriction, including 13 without limitation the rights to use, copy, modify, merge, publish, 14 distribute, sublicense, and/or sell copies of the Software, and to 15 permit persons to whom the Software is furnished to do so, subject to 16 the following conditions: 17 18 The above copyright notice and this permission notice shall be included 19 in all copies or substantial portions of the Software. 20 21 THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, 22 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 23 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 24 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 25 HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 26 WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 27 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 28 DEALINGS IN THE SOFTWARE. 29 ----------------------------------------------------------------------- */ 30 31 #ifndef __x86_64__ 32 33 #include <ffi.h> 34 #include <ffi_common.h> 35 36 #include <stdlib.h> 37 38 /* ffi_prep_args is called by the assembly routine once stack space 39 has been allocated for the function's arguments */ 40 41 void ffi_prep_args(char *stack, extended_cif *ecif) 42 { 43 register unsigned int i; 44 register void **p_argv; 45 register char *argp; 46 register ffi_type **p_arg; 47 48 argp = stack; 49 50 if (ecif->cif->flags == FFI_TYPE_STRUCT) 51 { 52 *(void **) argp = ecif->rvalue; 53 argp += 4; 54 } 55 56 p_argv = ecif->avalue; 57 58 for (i = ecif->cif->nargs, p_arg = ecif->cif->arg_types; 59 i != 0; 60 i--, p_arg++) 61 { 62 size_t z; 63 64 /* Align if necessary */ 65 if ((sizeof(int) - 1) & (unsigned) argp) 66 argp = (char *) ALIGN(argp, sizeof(int)); 67 68 z = (*p_arg)->size; 69 if (z < sizeof(int)) 70 { 71 z = sizeof(int); 72 switch ((*p_arg)->type) 73 { 74 case FFI_TYPE_SINT8: 75 *(signed int *) argp = (signed int)*(SINT8 *)(* p_argv); 76 break; 77 78 case FFI_TYPE_UINT8: 79 *(unsigned int *) argp = (unsigned int)*(UINT8 *)(* p_argv); 80 break; 81 82 case FFI_TYPE_SINT16: 83 *(signed int *) argp = (signed int)*(SINT16 *)(* p_argv); 84 break; 85 86 case FFI_TYPE_UINT16: 87 *(unsigned int *) argp = (unsigned int)*(UINT16 *)(* p_argv); 88 break; 89 90 case FFI_TYPE_SINT32: 91 *(signed int *) argp = (signed int)*(SINT32 *)(* p_argv); 92 break; 93 94 case FFI_TYPE_UINT32: 95 *(unsigned int *) argp = (unsigned int)*(UINT32 *)(* p_argv); 96 break; 97 98 case FFI_TYPE_STRUCT: 99 *(unsigned int *) argp = (unsigned int)*(UINT32 *)(* p_argv); 100 break; 101 102 default: 103 FFI_ASSERT(0); 104 } 105 } 106 else 107 { 108 memcpy(argp, *p_argv, z); 109 } 110 p_argv++; 111 argp += z; 112 } 113 114 return; 115 } 116 117 /* Perform machine dependent cif processing */ 118 ffi_status ffi_prep_cif_machdep(ffi_cif *cif) 119 { 120 /* Set the return type flag */ 121 switch (cif->rtype->type) 122 { 123 case FFI_TYPE_VOID: 124 #ifdef X86 125 case FFI_TYPE_STRUCT: 126 #endif 127 #if defined(X86) || defined(X86_DARWIN) 128 case FFI_TYPE_UINT8: 129 case FFI_TYPE_UINT16: 130 case FFI_TYPE_SINT8: 131 case FFI_TYPE_SINT16: 132 #endif 133 134 case FFI_TYPE_SINT64: 135 case FFI_TYPE_FLOAT: 136 case FFI_TYPE_DOUBLE: 137 case FFI_TYPE_LONGDOUBLE: 138 cif->flags = (unsigned) cif->rtype->type; 139 break; 140 141 case FFI_TYPE_UINT64: 142 cif->flags = FFI_TYPE_SINT64; 143 break; 144 145 #ifndef X86 146 case FFI_TYPE_STRUCT: 147 if (cif->rtype->size == 1) 148 { 149 cif->flags = FFI_TYPE_SMALL_STRUCT_1B; /* same as char size */ 150 } 151 else if (cif->rtype->size == 2) 152 { 153 cif->flags = FFI_TYPE_SMALL_STRUCT_2B; /* same as short size */ 154 } 155 else if (cif->rtype->size == 4) 156 { 157 cif->flags = FFI_TYPE_INT; /* same as int type */ 158 } 159 else if (cif->rtype->size == 8) 160 { 161 cif->flags = FFI_TYPE_SINT64; /* same as int64 type */ 162 } 163 else 164 { 165 cif->flags = FFI_TYPE_STRUCT; 166 } 167 break; 168 #endif 169 170 default: 171 cif->flags = FFI_TYPE_INT; 172 break; 173 } 174 175 #ifdef X86_DARWIN 176 cif->bytes = (cif->bytes + 15) & ~0xF; 177 #endif 178 179 return FFI_OK; 180 } 181 182 extern void ffi_call_SYSV(void (*)(char *, extended_cif *), extended_cif *, 183 unsigned, unsigned, unsigned *, void (*fn)(void)); 184 185 #ifdef X86_WIN32 186 extern void ffi_call_STDCALL(void (*)(char *, extended_cif *), extended_cif *, 187 unsigned, unsigned, unsigned *, void (*fn)(void)); 188 189 #endif /* X86_WIN32 */ 190 191 void ffi_call(ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue) 192 { 193 extended_cif ecif; 194 195 ecif.cif = cif; 196 ecif.avalue = avalue; 197 198 /* If the return value is a struct and we don't have a return */ 199 /* value address then we need to make one */ 200 201 if ((rvalue == NULL) && 202 (cif->flags == FFI_TYPE_STRUCT)) 203 { 204 ecif.rvalue = alloca(cif->rtype->size); 205 } 206 else 207 ecif.rvalue = rvalue; 208 209 210 switch (cif->abi) 211 { 212 case FFI_SYSV: 213 ffi_call_SYSV(ffi_prep_args, &ecif, cif->bytes, cif->flags, ecif.rvalue, 214 fn); 215 break; 216 #ifdef X86_WIN32 217 case FFI_STDCALL: 218 ffi_call_STDCALL(ffi_prep_args, &ecif, cif->bytes, cif->flags, 219 ecif.rvalue, fn); 220 break; 221 #endif /* X86_WIN32 */ 222 default: 223 FFI_ASSERT(0); 224 break; 225 } 226 } 227 228 229 /** private members **/ 230 231 static void ffi_prep_incoming_args_SYSV (char *stack, void **ret, 232 void** args, ffi_cif* cif); 233 void FFI_HIDDEN ffi_closure_SYSV (ffi_closure *) 234 __attribute__ ((regparm(1))); 235 unsigned int FFI_HIDDEN ffi_closure_SYSV_inner (ffi_closure *, void **, void *) 236 __attribute__ ((regparm(1))); 237 void FFI_HIDDEN ffi_closure_raw_SYSV (ffi_raw_closure *) 238 __attribute__ ((regparm(1))); 239 #ifdef X86_WIN32 240 void FFI_HIDDEN ffi_closure_STDCALL (ffi_closure *) 241 __attribute__ ((regparm(1))); 242 #endif 243 244 /* This function is jumped to by the trampoline */ 245 246 unsigned int FFI_HIDDEN 247 ffi_closure_SYSV_inner (closure, respp, args) 248 ffi_closure *closure; 249 void **respp; 250 void *args; 251 { 252 /* our various things... */ 253 ffi_cif *cif; 254 void **arg_area; 255 256 cif = closure->cif; 257 arg_area = (void**) alloca (cif->nargs * sizeof (void*)); 258 259 /* this call will initialize ARG_AREA, such that each 260 * element in that array points to the corresponding 261 * value on the stack; and if the function returns 262 * a structure, it will re-set RESP to point to the 263 * structure return address. */ 264 265 ffi_prep_incoming_args_SYSV(args, respp, arg_area, cif); 266 267 (closure->fun) (cif, *respp, arg_area, closure->user_data); 268 269 return cif->flags; 270 } 271 272 static void 273 ffi_prep_incoming_args_SYSV(char *stack, void **rvalue, void **avalue, 274 ffi_cif *cif) 275 { 276 register unsigned int i; 277 register void **p_argv; 278 register char *argp; 279 register ffi_type **p_arg; 280 281 argp = stack; 282 283 if ( cif->flags == FFI_TYPE_STRUCT ) { 284 *rvalue = *(void **) argp; 285 argp += 4; 286 } 287 288 p_argv = avalue; 289 290 for (i = cif->nargs, p_arg = cif->arg_types; (i != 0); i--, p_arg++) 291 { 292 size_t z; 293 294 /* Align if necessary */ 295 if ((sizeof(int) - 1) & (unsigned) argp) { 296 argp = (char *) ALIGN(argp, sizeof(int)); 297 } 298 299 z = (*p_arg)->size; 300 301 /* because we're little endian, this is what it turns into. */ 302 303 *p_argv = (void*) argp; 304 305 p_argv++; 306 argp += z; 307 } 308 309 return; 310 } 311 312 /* How to make a trampoline. Derived from gcc/config/i386/i386.c. */ 313 314 #define FFI_INIT_TRAMPOLINE(TRAMP,FUN,CTX) \ 315 ({ unsigned char *__tramp = (unsigned char*)(TRAMP); \ 316 unsigned int __fun = (unsigned int)(FUN); \ 317 unsigned int __ctx = (unsigned int)(CTX); \ 318 unsigned int __dis = __fun - (__ctx + 10); \ 319 *(unsigned char*) &__tramp[0] = 0xb8; \ 320 *(unsigned int*) &__tramp[1] = __ctx; /* movl __ctx, %eax */ \ 321 *(unsigned char *) &__tramp[5] = 0xe9; \ 322 *(unsigned int*) &__tramp[6] = __dis; /* jmp __fun */ \ 323 }) 324 325 #define FFI_INIT_TRAMPOLINE_STDCALL(TRAMP,FUN,CTX,SIZE) \ 326 ({ unsigned char *__tramp = (unsigned char*)(TRAMP); \ 327 unsigned int __fun = (unsigned int)(FUN); \ 328 unsigned int __ctx = (unsigned int)(CTX); \ 329 unsigned int __dis = __fun - (__ctx + 10); \ 330 unsigned short __size = (unsigned short)(SIZE); \ 331 *(unsigned char*) &__tramp[0] = 0xb8; \ 332 *(unsigned int*) &__tramp[1] = __ctx; /* movl __ctx, %eax */ \ 333 *(unsigned char *) &__tramp[5] = 0xe8; \ 334 *(unsigned int*) &__tramp[6] = __dis; /* call __fun */ \ 335 *(unsigned char *) &__tramp[10] = 0xc2; \ 336 *(unsigned short*) &__tramp[11] = __size; /* ret __size */ \ 337 }) 338 339 /* the cif must already be prep'ed */ 340 341 ffi_status 342 ffi_prep_closure_loc (ffi_closure* closure, 343 ffi_cif* cif, 344 void (*fun)(ffi_cif*,void*,void**,void*), 345 void *user_data, 346 void *codeloc) 347 { 348 if (cif->abi == FFI_SYSV) 349 { 350 FFI_INIT_TRAMPOLINE (&closure->tramp[0], 351 &ffi_closure_SYSV, 352 (void*)codeloc); 353 } 354 #ifdef X86_WIN32 355 else if (cif->abi == FFI_STDCALL) 356 { 357 FFI_INIT_TRAMPOLINE_STDCALL (&closure->tramp[0], 358 &ffi_closure_STDCALL, 359 (void*)codeloc, cif->bytes); 360 } 361 #endif 362 else 363 { 364 return FFI_BAD_ABI; 365 } 366 367 closure->cif = cif; 368 closure->user_data = user_data; 369 closure->fun = fun; 370 371 return FFI_OK; 372 } 373 374 /* ------- Native raw API support -------------------------------- */ 375 376 #if !FFI_NO_RAW_API 377 378 ffi_status 379 ffi_prep_raw_closure_loc (ffi_raw_closure* closure, 380 ffi_cif* cif, 381 void (*fun)(ffi_cif*,void*,ffi_raw*,void*), 382 void *user_data, 383 void *codeloc) 384 { 385 int i; 386 387 if (cif->abi != FFI_SYSV) { 388 return FFI_BAD_ABI; 389 } 390 391 // we currently don't support certain kinds of arguments for raw 392 // closures. This should be implemented by a separate assembly language 393 // routine, since it would require argument processing, something we 394 // don't do now for performance. 395 396 for (i = cif->nargs-1; i >= 0; i--) 397 { 398 FFI_ASSERT (cif->arg_types[i]->type != FFI_TYPE_STRUCT); 399 FFI_ASSERT (cif->arg_types[i]->type != FFI_TYPE_LONGDOUBLE); 400 } 401 402 403 FFI_INIT_TRAMPOLINE (&closure->tramp[0], &ffi_closure_raw_SYSV, 404 codeloc); 405 406 closure->cif = cif; 407 closure->user_data = user_data; 408 closure->fun = fun; 409 410 return FFI_OK; 411 } 412 413 static void 414 ffi_prep_args_raw(char *stack, extended_cif *ecif) 415 { 416 memcpy (stack, ecif->avalue, ecif->cif->bytes); 417 } 418 419 /* we borrow this routine from libffi (it must be changed, though, to 420 * actually call the function passed in the first argument. as of 421 * libffi-1.20, this is not the case.) 422 */ 423 424 extern void 425 ffi_call_SYSV(void (*)(char *, extended_cif *), extended_cif *, unsigned, 426 unsigned, unsigned *, void (*fn)(void)); 427 428 #ifdef X86_WIN32 429 extern void 430 ffi_call_STDCALL(void (*)(char *, extended_cif *), extended_cif *, unsigned, 431 unsigned, unsigned *, void (*fn)(void)); 432 #endif /* X86_WIN32 */ 433 434 void 435 ffi_raw_call(ffi_cif *cif, void (*fn)(void), void *rvalue, ffi_raw *fake_avalue) 436 { 437 extended_cif ecif; 438 void **avalue = (void **)fake_avalue; 439 440 ecif.cif = cif; 441 ecif.avalue = avalue; 442 443 /* If the return value is a struct and we don't have a return */ 444 /* value address then we need to make one */ 445 446 if ((rvalue == NULL) && 447 (cif->rtype->type == FFI_TYPE_STRUCT)) 448 { 449 ecif.rvalue = alloca(cif->rtype->size); 450 } 451 else 452 ecif.rvalue = rvalue; 453 454 455 switch (cif->abi) 456 { 457 case FFI_SYSV: 458 ffi_call_SYSV(ffi_prep_args_raw, &ecif, cif->bytes, cif->flags, 459 ecif.rvalue, fn); 460 break; 461 #ifdef X86_WIN32 462 case FFI_STDCALL: 463 ffi_call_STDCALL(ffi_prep_args_raw, &ecif, cif->bytes, cif->flags, 464 ecif.rvalue, fn); 465 break; 466 #endif /* X86_WIN32 */ 467 default: 468 FFI_ASSERT(0); 469 break; 470 } 471 } 472 473 #endif 474 475 #endif /* __x86_64__ */ 476
